﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace V82.ОбщиеМодули
{
	public partial class ЭлектронныеДокументыСлужебный
	{
		////////////////////////////////////////////////////////////////////////////////
		// ЭлектронныеДокументыСлужебный: механизм обмена электронными документами.
		//
		////////////////////////////////////////////////////////////////////////////////
		////////////////////////////////////////////////////////////////////////////////
		// СЛУЖЕБНЫЙ ПРОГРАММНЫЙ ИНТЕРФЕЙС
		////////////////////////////////////////////////////////////////////////////////
		// Получение данных объектов для сравнения
		// Получает таблицу реквизитов шапки передаваемого объекта.
		//
		// Параметры
		//  Объект           - Ссылка на объект, реквизиты шапки которого надо получить.
		//  РеквизитыОбъекта - Строка содержащая названия реквизитов через запятую
		//  ИмяОбъекта       - Строка, название объектов метаданных
		//

		public object ПолучитьТаблицуРеквизитовШапки(/*СсылкаНаОбъект, РеквизитыОбъекта, ИмяОбъекта*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ " + РеквизитыОбъекта + " ИЗ " + ИмяОбъекта + " КАК ТекущийОбъект
	|ГДЕ
	|	ТекущийОбъект.Ссылка = &Ссылка";*/
			//Запрос.УстановитьПараметр("Ссылка", СсылкаНаОбъект);
			return null;
		}
		// Получает таблицу реквизитов табличной части передаваемого объекта.
		//
		// Параметры:
		//  Объект - Ссылка на объект, реквизиты табличной части которого надо получить.
		//  СтрокаТаблицыРеквизитов - Строка таблицы значений, набор наименований необходимых реквизитов для получения.
		//

		public object ПолучитьТаблицуРеквизитовТабличнойЧасти(/*Объект, РеквизитыОбъекта, ИмяОбъекта, ИмяТабличнойЧасти*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ "+ РеквизитыОбъекта + " ИЗ " + ИмяОбъекта + "." + ИмяТабличнойЧасти + " КАК ТекущийОбъектИмяТабличнойЧасти
	|ГДЕ
	|	ТекущийОбъектИмяТабличнойЧасти.Ссылка = &Ссылка";*/
			//Запрос.УстановитьПараметр("Ссылка", Объект.Ссылка);
			return null;
		}
		// Проверяет переданные таблицы реквизитов на совпадения.
		//
		// Параметры:
		//  Таблица1, Таблица2 - таблицы значений, реквизиты, которые надо проверить на совпадение,
		//  РеквизитыОбъекта   - строка, содержит реквизиты, перечисленные через запятую,
		//  ДопПараметры       - структура дополнительных параметров, по которым надо проводить сравнение.
		//

		public object ТаблицыРеквизитовОбъектовОдинаковые(/*Таблица1, Таблица2, РеквизитыОбъекта, ДопПараметры = Неопределено*/)
		{
			//ДобавитьИтераторТаблице(Таблица1, +1);
			//ДобавитьИтераторТаблице(Таблица2, -1);
			//ТаблицаРезультат = Таблица1.Скопировать();
			//ОбщегоНазначенияКлиентСервер.ДополнитьТаблицу(Таблица2, ТаблицаРезультат);
			//ТаблицаРезультат.Свернуть(РеквизитыОбъекта, "ИтераторТаблицыРеквизитовОбъекта");
			//КоличествоОдинаковыхСтрок = ТаблицаРезультат.НайтиСтроки(Новый Структура("ИтераторТаблицыРеквизитовОбъекта", 0)).Количество();
			//КоличествоСтрокТаблицы = ТаблицаРезультат.Количество();
			//ПризнакСовпадения = КоличествоОдинаковыхСтрок = КоличествоСтрокТаблицы;
			if(true/*НЕ ПризнакСовпадения И ЗначениеЗаполнено(ДопПараметры)*/)
			{
				if(true/*ДопПараметры.Свойство("ИмяТабличнойЧасти")*/)
				{
					//ИмяТабличнойЧасти = ДопПараметры.ИмяТабличнойЧасти;
				}
				if(true/*ДопПараметры.Свойство("СтрокаДереваСравнения")*/)
				{
					//СтрокаДереваСравнения = ДопПараметры.СтрокаДереваСравнения;
				}
				if(true/*ИмяТабличнойЧасти = "Шапка"*/)
				{
					//НовСтрокаДереваМесто = СтрокаДереваСравнения.Строки.Добавить();
					//НовСтрокаДереваМесто.Место = "Реквизиты шапки";
				}
			}
			return null;
		}
		// Получает таблицу с ключевыми реквизитами объекта
		//
		// Параметры
		//  ИмяОбъекта - строка, имя объекта конфигурации, ключевые реквизиты которого необходимо получить.
		//

		public object ПолучитьТаблицуКлючевыхРеквизитовОбъекта(/*ИмяОбъекта*/)
		{
			//ТаблицаРеквизитов = ИнициализацияТаблицыРеквизитовОбъектов();
			if(true/*ИмяОбъекта = "Документ.ПакетЭД"*/)
			{
			}
			//СтруктураКлючевыхРеквизитов = Новый Структура;
			if(true/*ИмяОбъекта = "Документ.ПроизвольныйЭД"*/)
			{
				//СтрокаРеквизитовОбъекта = "Дата, Номер, Организация, Контрагент, Текст";
				//СтруктураКлючевыхРеквизитов.Вставить("Шапка", СтрокаРеквизитовОбъекта);
			}
			if(true/*НЕ ЗначениеЗаполнено(СтруктураКлючевыхРеквизитов)*/)
			{
				//ШаблонСообщения = НСтр("ru = 'Не определена структура ключевых реквизитов для объекта %1.'");
				//ТекстСообщения = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ШаблонСообщения, ИмяОбъекта);
				//ВызватьИсключение(ТекстСообщения);
			}
			//ТекПорядок = -50;
			//ТаблицаРеквизитов.Сортировать("Порядок Возр");
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Заполнение объектов
		// Устанавливает статус документа ПакетЭД.
		//
		// Параметры:
		//  Пакет - Ссылка на документ ПакетЭД
		//  СтатусПакета - ссылка на перечисление СтатусыПакетовЭД
		//

		public void УстановитьСтатусПакета(/*Пакет, СтатусПакета*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ПакетЭДОбъект = Пакет.ПолучитьОбъект();
			//ПакетЭДОбъект.СтатусПакета = СтатусПакета;
			//ПакетЭДОбъект.Записать();
		}
		// Получает выборку элементов справочника ЭДПрисоединенныеФайлы по отбору
		//
		// Параметры:
		//  Параметры - Структура, Ключ - название реквизита отбора, Значение - значение отбора
		//

		public object ПолучитьВыборкуЭДПоОтбору(/*Параметры*/)
		{
			if(true/*НЕ ТипЗнч(Параметры) = Тип("Структура") ИЛИ Параметры.Количество() = 0*/)
			{
			}
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ 
	|	ЭДПрисоединенныеФайлы.Наименование,
	|	ЭДПрисоединенныеФайлы.Ссылка
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ 
	|";*/
			//ПервыйЭлемент = Истина;
			return null;
		}
		// Возвращает ссылка на элемент справочника
		//
		// Параметры:
		//  Наименование - Строка, название справочника в метаданных
		//  ИД - Уникальный идентификатор элемента
		//
		// Возвращаемое значение:
		//  Ссылка на элемент справочника
		//

		public object ЭлементСправочникаПоИД(/*Наименование, ИД*/)
		{
			//Результат = Неопределено;
			//ИмяПрикладногоСправочника = ЭлектронныеДокументыПовтИсп.ПолучитьИмяПрикладногоСправочника(Наименование);
			if(true/*ЗначениеЗаполнено(ИмяПрикладногоСправочника)*/)
			{
				if(true/*ЗначениеЗаполнено(ИД)*/)
				{
					//UID = Новый УникальныйИдентификатор(ИД);
					//Результат = Справочники[ИмяПрикладногоСправочника].ПолучитьСсылку(UID);
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Отборы по элементу
		// Устанавливает отбор по элементу при загрузке настроек.
		//
		// Параметры:
		//  Форма - ссылка на форму, в которой надо провести отбор,
		//  СписокДанных - список, в котором будет проводиться отбор,
		//  ВидЭлемента - строка, вид элемента, по которому будет проводиться отбор,
		//  Настройки - структура настроек формы.
		//

		public void ОтборПоЭлементуПриЗагрузкеИзНастроек(/*Форма, СписокДанных, ВидЭлемента, Настройки*/)
		{
			//ЗначениеЭлемента = Настройки.Получить(ВидЭлемента);
			if(true/*ЗначениеЗаполнено(ЗначениеЭлемента)*/)
			{
				//Форма[ВидЭлемента] = ЗначениеЭлемента;
				//УстановитьОтборВСпискеПоЭлементу(СписокДанных, ВидЭлемента, ЗначениеЭлемента);
			}
			//Настройки.Удалить(ВидЭлемента);
		}
		// Устанавливает отбор в списке данных по элементу.
		//
		// Параметры:
		//  СписокДанных - список, в котором будет проводиться отбор,
		//  ВидЭлемента - строка, вид элемента, по которому будет проводиться отбор,
		//  ЗначениеЭлемента - значение, которое будет передано отбору.
		//

		public void УстановитьОтборВСпискеПоЭлементу(/*СписокДанных, ВидЭлемента, ЗначениеЭлемента*/)
		{
			/*ОбщегоНазначенияКлиентСервер.УстановитьЭлементОтбора(
		СписокДанных.Отбор, ВидЭлемента, ЗначениеЭлемента, ВидСравненияКомпоновкиДанных.Равно, , ЗначениеЗаполнено(ЗначениеЭлемента));*/
		}
		////////////////////////////////////////////////////////////////////////////////
		// Регламентные задания
		// Выполняет регламентное задание по получению
		// новых электронных документов.
		//
		// Параметры:
		//  ОписаниеОшибки - строка, описание ошибки, в случае ее возникновения в ходе получения документов.
		//

		public void РегламентноеПолучениеНовыхЭД(/**/)
		{
			if(true/*ПустаяСтрока(ИмяПользователя())*/)
			{
				//УстановитьПривилегированныйРежим(Истина);
			}
			/*ЗаписьЖурналаРегистрации(НСтр("ru = 'Получение новых эл.документов'"), УровеньЖурналаРегистрации.Информация, , ,
		НСтр("ru = 'Начато регламентное задание по получению новых эл.документов.'"));*/
			//НачатьТранзакцию();
		}
		// Выполняет регламентное задание по фактической отправке
		// электронных документов.
		//

		public void РегламентнаяОтправкаОформленныхЭД(/**/)
		{
			if(true/*ПустаяСтрока(ИмяПользователя())*/)
			{
				//УстановитьПривилегированныйРежим(Истина);
			}
			/*ЗаписьЖурналаРегистрации(НСтр("ru = 'Отправка оформленных эл.документов'"), УровеньЖурналаРегистрации.Информация, , ,
		НСтр("ru = 'Начато регламентное задание по отправке оформленных эл.документов.'"));*/
			//НачатьТранзакцию();
		}
		// Только для внутреннего использования

		public object ОтправитьИПолучитьДокументы(/*СоответствиеПаролейДляЭДО*/)
		{
			//СтруктураВозврата = Новый Структура;
			//СтруктураВозврата.Вставить("КолОтправленныхПакетов", ОтправкаСформированныхЭД(СоответствиеПаролейДляЭДО));
			//СтруктураВозврата.Вставить("НовыеДокументы", ПолучитьНовыеЭД(СоответствиеПаролейДляЭДО));
			return null;
		}
		// Только для внутреннего использования

		public object ОтправкаПакетовЭД(/*МассивПакетовЭД, СоответствиеПаролейДляЭДО*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//РезультатОтправки = 0;
			if(true/*НЕ ПустаяСтрока(АдресКаталогаОтправки)*/)
			{
				//УдалитьФайлы(АдресКаталогаОтправки);
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с сертификатами ЭЦП
		// Создает новый элемент справочника "СертификатыЭЦП"
		// и заполняет его переданными данными.
		//
		// Параметры:
		//  СтруктураСертификата - структура данных для заполнения элемента справочника
		//  ОписаниеОшибки - строка - описание ошибки при ее возникновении.
		//

		public object ЗагрузитьСертификат(/*СтруктураСертификата, ОписаниеОшибки*/)
		{
			//НовыйЭлемент = Справочники.СертификатыЭЦП.СоздатьЭлемент();
			//НовыйЭлемент.Отпечаток    = СтруктураСертификата.Отпечаток;
			//НовыйЭлемент.Наименование = СтруктураСертификата.КомуВыдан;
			//НовыйЭлемент.Организация  = СтруктураСертификата.Организация;
			//СтрокаОписания = "Кому выдан: " + СтруктураСертификата.КомуВыдан + Символы.ПС;
			//СтрокаОписания = СтрокаОписания + "Кем выдан: " + СтруктураСертификата.КемВыдан + Символы.ПС;
			//СтрокаОписания = СтрокаОписания + "Действителен: " + СтруктураСертификата.ДействителенДо + Символы.ПС;
			//НовоеНазначение = "";
			//ЭлектроннаяЦифроваяПодпись.ЗаполнитьНазначениеСертификата(СтруктураСертификата.Назначение, НовоеНазначение, Истина);
			//СтрокаОписания = СтрокаОписания + НовоеНазначение;
			//НовыйЭлемент.Назначение = СтрокаОписания;
			if(true/*СтруктураСертификата.Свойство("ДвоичныеДанныеСертификата")
		И ЗначениеЗаполнено(СтруктураСертификата.ДвоичныеДанныеСертификата)*/)
			{
				//ДанныеХранилища = Новый ХранилищеЗначения(СтруктураСертификата.ДвоичныеДанныеСертификата, Новый СжатиеДанных(9));
				//НовыйЭлемент.ФайлСертификата = ДанныеХранилища;
				//НовыйЭлемент.Записать();
			}
			return null;
		}
		// Получает массив сертификатов, которые указаны в соглашении,
		// а также предназначены для организации из соглашения.
		//
		// Параметры:
		//  ТекущееСоглашение - СправочникСсылка.СоглашениеОбОбменеЭД, соглашение,
		//                      сертификаты по которому надо получить.
		//

		public object ПолучитьОтпечаткиОжидаемыхСертификатов(/*ТекущееСоглашение*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СертификатыЭЦП.Отпечаток КАК Отпечаток
	|ИЗ
	|	Справочник.СертификатыЭЦП КАК СертификатыЭЦП
	|ГДЕ
	|	СертификатыЭЦП.Организация = &Организация
	|	И СертификатыЭЦП.Отозван = ЛОЖЬ
	|	И СертификатыЭЦП.ПометкаУдаления = ЛОЖЬ
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ
	|	СоглашенияОбИспользованииЭДСертификатыПодписейКонтрагента.Отпечаток
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД.СертификатыПодписейКонтрагента КАК СоглашенияОбИспользованииЭДСертификатыПодписейКонтрагента
	|ГДЕ
	|	СоглашенияОбИспользованииЭДСертификатыПодписейКонтрагента.Ссылка = &СоглашениеОбИспользованииЭД";*/
			//Запрос.УстановитьПараметр("Организация", ТекущееСоглашение.Организация);
			//Запрос.УстановитьПараметр("СоглашениеОбИспользованииЭД", ТекущееСоглашение);
			//МассивОтпечатков = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Отпечаток");
			return null;
		}
		// Проверяет наличие элементов справочника организации
		// и возвращает элемент, если он единственный.
		//
		// Параметры:
		//  ЕстьОрганизации - Булево - в справочнике есть элементы
		//  Организация - СправочникСсылка.Организации - ссылка на единственный элемент справочника Организации
		//

		public void ПроверитьНаличиеОрганизаций(/*ЕстьОрганизации, Организация*/)
		{
			//ЕстьОрганизации = Истина;
			//СписокОрганизаций = Новый СписокЗначений;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ РАЗРЕШЕННЫЕ
	|	Организации.Ссылка
	|ИЗ
	|	Справочник.Организации КАК Организации";*/
			//СписокОрганизаций.ЗагрузитьЗначения(Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка"));
			if(true/*СписокОрганизаций.Количество() = 0*/)
			{
				//ТекстСообщения = НСтр("ru='Нет данных по организациям.'");
				//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(ТекстСообщения);
				//ЕстьОрганизации = Ложь;
			}
		}
		// Только для внутреннего использования

		public void СохранитьВместеСПоследнейЭЦП(/*ПрисоединенныйФайл,
										ДанныеФайла,
										УникальныйИдентификатор,
										АдресКаталога,
										СоответствиеФайлЭД*/)
		{
			//ПолноеИмяФайла = АдресКаталога+ СтрЗаменить(ДанныеФайла.ИмяФайла, "..",".");
			//МассивСтруктурПодписей = ЭлектроннаяЦифроваяПодпись.ПолучитьВсеПодписи(ПрисоединенныйФайл, УникальныйИдентификатор);
			//Файл = Новый Файл(АдресКаталога);
			if(true/*Не Файл.Существует()*/)
			{
				//СоздатьКаталог(АдресКаталога);
			}
			if(true/*ТипЗнч(МассивСтруктурПодписей) = Тип("Массив") И МассивСтруктурПодписей.Количество() > 0*/)
			{
				/*СохранитьПодписи(ПрисоединенныйФайл, ПолноеИмяФайла, УникальныйИдентификатор, МассивСтруктурПодписей, АдресКаталога,
			СоответствиеФайлЭД, Истина);*/
			}
		}
		// Только для внутреннего использования

		public void СохранитьВместеСЭЦП(/*ПрисоединенныйФайл,
								ДанныеФайла,
								УникальныйИдентификатор,
								АдресКаталога,
								СсылкаНаПакет,
								СоответствиеФайлЭД,
								ЭтоПроизвольныйДокумент = Неопределено*/)
		{
			/*// Для подтверждения необходимо в каталог формирования файлов сохранить только последнюю подпись
*/
			/*ПолноеИмяФайла = СохранитьФайлКак(ДанныеФайла, АдресКаталога, ПрисоединенныйФайл, СсылкаНаПакет,
		ЭтоПроизвольныйДокумент, СоответствиеФайлЭД);*/
			if(true/*ПолноеИмяФайла = ""*/)
			{
			}
			//МассивСтруктурПодписей = ЭлектроннаяЦифроваяПодпись.ПолучитьВсеПодписи(ПрисоединенныйФайл, УникальныйИдентификатор);
			if(true/*ТипЗнч(МассивСтруктурПодписей) = Тип("Массив") И МассивСтруктурПодписей.Количество() > 0*/)
			{
				/*СохранитьПодписи(ПрисоединенныйФайл, ПолноеИмяФайла, УникальныйИдентификатор, МассивСтруктурПодписей, АдресКаталога,
			СоответствиеФайлЭД, , ЭтоПроизвольныйДокумент);*/
			}
		}

		public object ВыборкаДопДанныеЭД(/*ЭДВладелец*/)
		{
			/*// Для одного ЭД может быть сформирован один ЭД-доп.данных.
*/
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
		"ВЫБРАТЬ ПЕРВЫЕ 1
		|	ЭДПрисоединенныеФайлы.Ссылка
		|ИЗ
		|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
		|ГДЕ
		|	ЭДПрисоединенныеФайлы.ЭлектронныйДокументВладелец = &ЭлектронныйДокументВладелец
		|	И ЭДПрисоединенныеФайлы.ВидЭД = ЗНАЧЕНИЕ(Перечисление.ВидыЭД.ДопДанные)
		|	И ЭДПрисоединенныеФайлы.НаправлениеЭД = ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Исходящий)";*/
			//Запрос.УстановитьПараметр("ЭлектронныйДокументВладелец", ЭДВладелец);
			return null;
		}

		public void СохранитьФайлыДопДанныхЭД(/*ПрисоединенныйФайл, ИмяКаталога, ДеревоДанных*/)
		{
			if(true/*ЗначениеЗаполнено(ПрисоединенныйФайл) И ТипЗнч(ДеревоДанных) = Тип("ДеревоЗначений")*/)
			{
				/*// Для одного ЭД может быть сформирован один ЭД-доп.данных.
*/
				//Выборка = ВыборкаДопДанныеЭД(ПрисоединенныйФайл);
				if(true/*Выборка.Следующий()*/)
				{
					//Файл = Новый Файл(ИмяКаталога);
					if(true/*НЕ Файл.Существует()*/)
					{
						//СоздатьКаталог(ИмяКаталога);
					}
					//ДанныеФайла = ПрисоединенныеФайлы.ПолучитьДанныеФайла(Выборка.Ссылка);
					//ИмяПолучаемогоФайла = СтрЗаменить(ДанныеФайла.ИмяФайла, "..", ".");
					//ДвоичныеДанныеФайла = ПолучитьИзВременногоХранилища(ДанныеФайла.СсылкаНаДвоичныеДанныеФайла);
					//ДвоичныеДанныеФайла.Записать(ИмяКаталога + ИмяПолучаемогоФайла);
					//СтрокаВладелец = ДеревоДанных.Строки.Найти(ПрисоединенныйФайл.НомерЭД, "НомерЭД");
					if(true/*СтрокаВладелец = Неопределено*/)
					{
						//СтрокаВладелец = ДеревоДанных.Строки.Добавить();
						//СтрокаВладелец.НомерЭД = ПрисоединенныйФайл.НомерЭД;
					}
					//НоваяСтрока = СтрокаВладелец.Строки.Добавить();
					//НоваяСтрока.ПсевдонимФайла = ИмяПолучаемогоФайла;
					//НоваяСтрока.ЭтоПодпись = Ложь;
					//НоваяСтрока.ИмяФайла = ИмяПолучаемогоФайла;
				}
			}
		}
		// Только для внутреннего использования

		public object РезультатЗапросаПоСертификатам(/*МассивСоглашений*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ РАЗРЕШЕННЫЕ РАЗЛИЧНЫЕ
	|	СертификатыЭЦП.Ссылка,
	|	СоглашенияОбИспользованииЭД.Ссылка КАК Соглашение
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД КАК СоглашенияОбИспользованииЭД
	|		ЛЕВОЕ СОЕДИНЕНИЕ Справочник.СертификатыЭЦП КАК СертификатыЭЦП
	|		ПО СоглашенияОбИспользованииЭД.СертификатАбонента = СертификатыЭЦП.Ссылка
	|ГДЕ
	|	НЕ СертификатыЭЦП.ЗапомнитьПарольКСертификату
	|	И НЕ СертификатыЭЦП.ПометкаУдаления
	|	И ВЫБОР
	|			КОГДА СертификатыЭЦП.ОграничитьДоступКСертификату
	|				ТОГДА СертификатыЭЦП.Пользователь = &Пользователь
	|			ИНАЧЕ ИСТИНА
	|		КОНЕЦ
	|	И НЕ СоглашенияОбИспользованииЭД.ПометкаУдаления
	|	И СоглашенияОбИспользованииЭД.СтатусСоглашения = ЗНАЧЕНИЕ(Перечисление.СтатусыСоглашенийЭД.Действует)
	|	И СоглашенияОбИспользованииЭД.СпособОбменаЭД = ЗНАЧЕНИЕ(перечисление.СпособыОбменаЭД.ЧерезОператораЭДОТакском)
	|	И СоглашенияОбИспользованииЭД.Ссылка В (&МассивСоглашений)
	|
	|УПОРЯДОЧИТЬ ПО
	|	СертификатыЭЦП.Представление";*/
			//Запрос.УстановитьПараметр("Пользователь", ПользователиСервер.ТекущийПользователь());
			if(true/*МассивСоглашений = Неопределено ИЛИ МассивСоглашений.Количество() = 0*/)
			{
				//Запрос.Текст = СтрЗаменить(Запрос.Текст, "И СоглашенияОбИспользованииЭД.Ссылка В (&МассивСоглашений)", "");
			}
			//Выгрузка = Запрос.Выполнить().Выгрузить();
			//СписокВыбора = Новый СписокЗначений;
			//СписокВыбора.ЗагрузитьЗначения(Выгрузка.ВыгрузитьКолонку("Ссылка"));
			return null;
		}
		// Получение актуальных сертификатов для подписи электронных документов
		// Только для внутреннего использования

		public object ТаблицаДоступныхДляПодписиСертификатов(/*МассивСтруктурСертификатов*/)
		{
			return null;
		}
		// Только для внутреннего использования

		public object МассивСтруктурДоступныхДляПодписиСертификатов(/*МассивСтруктурСертификатов*/)
		{
			//МассивСтруктурДоступныхСертификатов = Новый Массив;
			//ТаблицаДоступныхСертификатов = ДоступныДляПодписиСертификаты(МассивСтруктурСертификатов);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с версиями электронных документов
		// Удаляет запись из регистра сведений СостоянияЭД с отбором по объекту
		//
		// Параметры:
		//  СсылкаНаОбъект - Ссылка на объект ИБ, для которого требуется удалить запись из регистра
		//

		public void ПроверитьНаличиеИУдалитьСостояниеДокумента(/*СсылкаНаОбъект*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//МенеджерЗаписи = РегистрыСведений.СостоянияЭД.СоздатьМенеджерЗаписи();
			//МенеджерЗаписи.СсылкаНаОбъект = СсылкаНаОбъект;
			//МенеджерЗаписи.Прочитать();
			if(true/*МенеджерЗаписи.Выбран()*/)
			{
				//МенеджерЗаписи.Удалить();
			}
		}
		// Устанавливает новую версию электронного документа для владельца.
		//
		// Параметры:
		//  СсылкаНаОбъект - Ссылка на документ базы данных, номер версии электронного документа которого надо изменить,
		//  ПрисоединенныйФайл - ссылка на электронный документ, который в данный момент является актуальным
		//

		public void УстановитьНовуюВерсиюЭД(/*СсылкаНаОбъект, ПрисоединенныйФайл = Неопределено, УдалятьСтаруюВерсию = Ложь*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//НаборЗаписей = РегистрыСведений.СостоянияЭД.СоздатьНаборЗаписей();
			//НаборЗаписей.Отбор.СсылкаНаОбъект.Установить(СсылкаНаОбъект);
			//НаборЗаписей.Прочитать();
			if(true/*НаборЗаписей.Количество() = 0*/)
			{
				//НоваяЗаписьНабора = НаборЗаписей.Добавить();
				//НоваяЗаписьНабора.СсылкаНаОбъект      = СсылкаНаОбъект;
				/*НоваяЗаписьНабора.ЭлектронныйДокумент = ?(ПрисоединенныйФайл = Неопределено,
		Справочники.ЭДПрисоединенныеФайлы.ПустаяСсылка(), ПрисоединенныйФайл);*/
				/*НоваяЗаписьНабора.СостояниеВерсииЭД = ПолучитьПервоеСостояниеВерсииЭДДляВладельца(
		СсылкаНаОбъект, ЗначениеЗаполнено(ПрисоединенныйФайл));*/
			}
			if(true/*НоваяЗаписьНабора.СостояниеВерсииЭД = Перечисления.СостоянияВерсийЭД.НеСформирован*/)
			{
				//НоваяЗаписьНабора.ДействияСНашейСтороны             = Перечисления.СводныеСостоянияЭД.ТребуютсяДействия;
				//НоваяЗаписьНабора.ДействияСоСтороныДругогоУчастника = Перечисления.СводныеСостоянияЭД.ДействийНеТребуется;
			}
			//НаборЗаписей.Записать();
		}
		// При удалении ЭД, если ЭД актуален, производит сброс состояния владельца ЭД в первоначальное состояние
		//
		// Параметры:
		//  СсылкаНаОбъект - Ссылка на элемент справочника ЭДПрисоединенныеФайлы
		//

		public void ОбработатьУдалениеЭлектронногоДокумента(/*СсылкаНаОбъект*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*НЕ ЭтоСлужебныйДокумент(СсылкаНаОбъект)*/)
			{
				//ЗапросДокументовИБ = Новый Запрос;
				//ЗапросДокументовИБ.УстановитьПараметр("ЭлектронныйДокумент", СсылкаНаОбъект);
				/*ЗапросДокументовИБ.Текст =
		"ВЫБРАТЬ
		|	СостоянияЭД.СсылкаНаОбъект
		|ИЗ
		|	РегистрСведений.СостоянияЭД КАК СостоянияЭД
		|ГДЕ
		|	СостоянияЭД.ЭлектронныйДокумент = &ЭлектронныйДокумент";*/
				//ВыборкаДокументов = ЗапросДокументовИБ.Выполнить().Выбрать();
				while(true/*ВыборкаДокументов.Следующий()*/)
				{
					//НаборЗаписей = РегистрыСведений.СостоянияЭД.СоздатьНаборЗаписей();
					//НаборЗаписей.Отбор.СсылкаНаОбъект.Установить(ВыборкаДокументов.СсылкаНаОбъект);
					//НаборЗаписей.Прочитать();
					if(true/*НаборЗаписей.Количество() = 0*/)
					{
					}
					//НоваяЗаписьНабора.СостояниеВерсииЭД   = ПолучитьПервоеСостояниеВерсииЭДДляВладельца(ВыборкаДокументов.СсылкаНаОбъект);
					//НоваяЗаписьНабора.ЭлектронныйДокумент = Справочники.ЭДПрисоединенныеФайлы.ПустаяСсылка();
					//НаборЗаписей.Записать();
				}
				//;;
			}
		}
		// Получает таблицу значений с данными по электронным документам.
		//
		// Параметры:
		// МассивСсылокНаВладельцев - массив ссылок на владельцев электронных документов, данные которых необходимо получить.
		//

		public object ПолучитьДанныеЭДПоВладельцам(/*МассивСсылокНаВладельцев*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СостоянияЭД.СсылкаНаОбъект КАК ВладелецЭД,
	|	СостоянияЭД.СостояниеВерсииЭД КАК СостояниеВерсииЭД,
	|	СостоянияЭД.ДействияСНашейСтороны КАК ДействияСНашейСтороны,
	|	СостоянияЭД.ДействияСоСтороныДругогоУчастника КАК ДействияСоСтороныДругогоУчастника
	|ИЗ
	|	РегистрСведений.СостоянияЭД КАК СостоянияЭД
	|ГДЕ
	|	СостоянияЭД.СсылкаНаОбъект В(&МассивСсылокНаВладельцев)";*/
			//Запрос.УстановитьПараметр("МассивСсылокНаВладельцев", МассивСсылокНаВладельцев);
			//Результат = Запрос.Выполнить().Выгрузить();
			return null;
		}
		// Получает сопоставление владельцев и актуальных ЭД
		//
		// Параметры:
		//  МассивСсылокНаВладельцев - массив ссылок на владельцев электронных документов, данные которых необходимо получить.
		//

		public object ПолучитьСоответствиеВладельцевИЭД(/*МассивСсылокНаВладельцев*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СостоянияЭД.СсылкаНаОбъект КАК ВладелецЭД,
	|	ЕСТЬNULL(СостоянияЭД.ЭлектронныйДокумент, ЗНАЧЕНИЕ(Справочник.ЭДПрисоединенныеФайлы.ПустаяСсылка)) КАК СсылкаНаЭД
	|ИЗ
	|	РегистрСведений.СостоянияЭД КАК СостоянияЭД
	|ГДЕ
	|	СостоянияЭД.СсылкаНаОбъект В(&МассивСсылокНаВладельцев)";*/
			//Запрос.УстановитьПараметр("МассивСсылокНаВладельцев", МассивСсылокНаВладельцев);
			//Результат = Запрос.Выполнить().Выбрать();
			//СоответствиеВладельцевИЭД = Новый Соответствие;
			while(true/*Результат.Следующий()*/)
			{
				//СоответствиеВладельцевИЭД.Вставить(Результат.ВладелецЭд, Результат.СсылкаНаЭД);
			}
			return null;
		}
		// Получает текстовое представление версии электронного документа.
		//
		// Параметры:
		//  СсылкаНаВладельца - Ссылка на объект ИБ, состояние версии электронного документа которого необходимо получить.
		//  Гиперссылка - булево, Истина - необходимо реквизит формы "СостояниеЭД" сделать гиперссылкой.
		//

		public object ТекстСостоянияЭД(/*СсылкаНаВладельца, Гиперссылка*/)
		{
			//ТекстСостоянияЭД = "";
			if(true/*ЗначениеЗаполнено(СсылкаНаВладельца)*/)
			{
				if(true/*ИспользуетсяОбменЭД()*/)
				{
					/*ИмяСчетаФактурыВыданного = ЭлектронныеДокументыПовтИсп.ИмяНаличиеОбъектаРеквизитаВПрикладномРешении(
				"СчетФактураВыданныйВМетаданных");*/
					/*ИмяСчетаФактурыПолученного = ЭлектронныеДокументыПовтИсп.ИмяНаличиеОбъектаРеквизитаВПрикладномРешении(
				"СчетФактураПолученныйВМетаданных");*/
					if(true/*ИмяСчетаФактурыВыданного <> Неопределено
				И ТипЗнч(СсылкаНаВладельца) = Тип("ДокументСсылка." + ИмяСчетаФактурыВыданного)
				ИЛИ ИмяСчетаФактурыПолученного <> Неопределено
				И ТипЗнч(СсылкаНаВладельца) = Тип("ДокументСсылка." + ИмяСчетаФактурыПолученного)*/)
					{
						//ТекстСостоянияЭД = ПолучитьТекстСводногоСостоянияЭД(СсылкаНаВладельца);
					}
					//НастройкиОбмена = ОпределитьНастройкиОбменаЭДПоИсточнику(СсылкаНаВладельца, Ложь);
					if(true/*НЕ ЗначениеЗаполнено(ТекстСостоянияЭД) И НЕ ЗначениеЗаполнено(НастройкиОбмена)*/)
					{
						if(true/*НастройкиОбмена = Неопределено*/)
						{
							//ТекстСостоянияЭД = "Нет действующего соглашения об использовании ЭД";
						}
					}
				}
			}
			return null;
		}
		// Возвращает структуру версии электронного документа по владельцу.
		//
		// Параметры:
		//  СсылкаНаВладельца - Ссылка на документ ИБ, структуру версии электронного документа которого необходимо получить.
		//

		public object ПолучитьСтруктуруВерсииЭД(/*СсылкаНаВладельца*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//СтруктураВерсииЭД = Новый Структура;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	ЕСТЬNULL(СостоянияЭД.ЭлектронныйДокумент.НомерВерсииЭД, 0) КАК НомерВерсииЭД,
	|	ЕСТЬNULL(СостоянияЭД.ЭлектронныйДокумент, ЗНАЧЕНИЕ(Справочник.ЭДПрисоединенныеФайлы.ПустаяСсылка)) КАК ЭлектронныйДокумент,
	|	СостоянияЭД.СостояниеВерсииЭД,
	|	СостоянияЭД.ЭлектронныйДокумент.СтатусЭД КАК СтатусЭД
	|ИЗ
	|	РегистрСведений.СостоянияЭД КАК СостоянияЭД
	|ГДЕ
	|	СостоянияЭД.СсылкаНаОбъект = &СсылкаНаОбъект
	|;
	|
	|////////////////////////////////////////////////////////////////////////////////
	|ВЫБРАТЬ
	|	МАКСИМУМ(ЭДПрисоединенныеФайлы.НомерВерсииЭД) КАК НомерВерсииЭД
	|ПОМЕСТИТЬ МаксВерсия
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.ВладелецФайла = &СсылкаНаОбъект
	|	И (НЕ ЭДПрисоединенныеФайлы.ПометкаУдаления)
	|;
	|
	|////////////////////////////////////////////////////////////////////////////////
	|ВЫБРАТЬ
	|	ЭДПрисоединенныеФайлы.Ссылка,
	|	ЭДПрисоединенныеФайлы.НомерВерсииЭД,
	|	ЭДПрисоединенныеФайлы.СтатусЭД
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.ВладелецФайла = &СсылкаНаОбъект
	|	И ЭДПрисоединенныеФайлы.НомерВерсииЭД В
	|			(ВЫБРАТЬ
	|				МаксВерсия.НомерВерсииЭД
	|			ИЗ
	|				МаксВерсия)
	|	И (НЕ ЭДПрисоединенныеФайлы.ПометкаУдаления)
	|	И (ЭДПрисоединенныеФайлы.СтатусЭД = ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Сформирован)
	|			ИЛИ ЭДПрисоединенныеФайлы.СтатусЭД = ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Утвержден))";*/
			//Запрос.УстановитьПараметр("СсылкаНаОбъект", СсылкаНаВладельца);
			//Результат = Запрос.ВыполнитьПакет();
			//ВыборкаПоРегистру = Результат[0].Выбрать();
			if(true/*ВыборкаПоРегистру.Следующий()*/)
			{
				//НомерВерсииЭД     = ВыборкаПоРегистру.НомерВерсииЭД;
				//СостояниеВерсииЭД = ВыборкаПоРегистру.СостояниеВерсииЭД;
				//СсылкаНаДокумент  = ВыборкаПоРегистру.ЭлектронныйДокумент;
				//СтатусЭД          = ВыборкаПоРегистру.СтатусЭД;
			}
			if(true/*НомерВерсииЭД = 0*/)
			{
				//ВыборкаПоСправочнику = Результат[2].Выбрать();
				if(true/*ВыборкаПоСправочнику.Количество()>0*/)
				{
					//ВыборкаПоСправочнику.Следующий();
					//НомерВерсииЭД    = ВыборкаПоСправочнику.НомерВерсииЭД;
					//СсылкаНаДокумент = ВыборкаПоСправочнику.Ссылка;
					//СтатусЭД         = ВыборкаПоСправочнику.СтатусЭД;
				}
			}
			//СтруктураВерсииЭД.Вставить("НомерВерсииЭД",     НомерВерсииЭД);
			//СтруктураВерсииЭД.Вставить("СсылкаНаДокумент",  СсылкаНаДокумент);
			//СтруктураВерсииЭД.Вставить("СостояниеВерсииЭД", СостояниеВерсииЭД);
			//СтруктураВерсииЭД.Вставить("СтатусЭД",          СтатусЭД);
			return null;
		}
		// Получает номер текущей версии электронного документа для владельца.
		//
		// Параметры:
		//  СсылкаНаВладельца - Ссылка на объект ИБ, номер версии электронного документа которого надо получить.
		//

		public object НомерВерсииЭДПоВладельцу(/*СсылкаНаВладельца*/)
		{
			//СтруктураВерсииЭД = ПолучитьСтруктуруВерсииЭД(СсылкаНаВладельца);
			if(true/*ЗначениеЗаполнено(СтруктураВерсииЭД.НомерВерсииЭД)*/)
			{
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Подпись электронных документов на сервере
		// Выполняет добавление ЭЦП в электронный документ.
		//
		// Параметры:
		//  ПрисоединенныйФайл - Ссылка на элемент справочника, содержащего в себе электронный документ,
		//  ДанныеПодписи - Структура параметров ЭЦП.
		//

		public void ДобавитьПодпись(/*ПрисоединенныйФайл, ДанныеПодписи*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ПрисоединенныеФайлы.ЗанестиИнформациюОднойПодписи(ПрисоединенныйФайл, ДанныеПодписи);
			//ОпределитьСтатусыПодписей(ПрисоединенныйФайл);
			if(true/*ЭлектронныйДокументПолностьюПодписан(ПрисоединенныйФайл)*/)
			{
				//ФайлОбъект = ПрисоединенныйФайл.ПолучитьОбъект();
				if(true/*ПрисоединенныйФайл.НаправлениеЭД = Перечисления.НаправленияЭД.Интеркампани*/)
				{
					//ФайлОбъект.СтатусЭД = ПолучитьДопустимыйСтатусЭД(Перечисления.СтатусыЭД.ПолностьюПодписан, ПрисоединенныйФайл);
				}
				//ФайлОбъект.ДатаИзмененияСтатусаЭД = ТекущаяДатаСеанса();
				//ФайлОбъект.Записать();
				//ОбновитьВерсиюЭД(ФайлОбъект.Ссылка);
				//ЭлектронныеДокументыПереопределяемый.НазначенСтатусПодписан(ФайлОбъект.Ссылка);
			}
		}
		// Возвращает отпечаток сертификата криптографии по ссылке.
		//
		// Параметры:
		//  СертификатПодписи - Ссылка на элемент справочника, содержащего в себе сертификат криптографии.
		//

		public object ПолучитьОтпечатокСертификата(/*СертификатПодписи*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			return null;
		}
		// Проверяет все ли необходимые подписи установлены перед отправкой контрагенту.
		//
		// Параметры:
		//  ЭлектронныйДокумент - ссылка на присоединенный файл.
		//

		public object ЭлектронныйДокументПолностьюПодписан(/*ЭлектронныйДокумент*/)
		{
			//ФлагПодписанПолностью = Истина;
			if(true/*ЭлектронныйДокумент.ВидЭД = Перечисления.ВидыЭД.ПроизвольныйЭД*/)
			{
			}
			if(true/*ЭлектронныйДокумент.НаправлениеЭД = Перечисления.НаправленияЭД.Интеркампани*/)
			{
				//ТЗ = ЭлектронныйДокумент.ЭлектронныеЦифровыеПодписи.Выгрузить(, "Отпечаток");
				//ТЗ.Свернуть("Отпечаток");
				//ФлагПодписанПолностью = ТЗ.Количество() > 1;
			}
			//ЭлектронныеДокументыПереопределяемый.ЭлектронныйДокументПолностьюПодписан(ЭлектронныйДокумент, ФлагПодписанПолностью);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Получение почты
		// Только для внутреннего использования

		public void ЗаписатьДатуПолучения(/*ДокументСсылка, ДатаИзменения*/)
		{
		}
		// Только для внутреннего использования

		public void ЗаписатьДатуОтправки(/*ДокументСсылка, ДатаИзменения*/)
		{
		}
		// Только для внутреннего использования

		public object СформироватьНовыйПакетЭД(/*СтруктураПараметров*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			return null;
		}
		// Только для внутреннего использования

		public object ОпределитьДокументПоНомеруЭД(/*НомерЭД, Направление*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	ЭДПрисоединенныеФайлы.Ссылка
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.НомерЭД ПОДОБНО &НомерЭД
	|	И ЭДПрисоединенныеФайлы.НаправлениеЭД = &НаправлениеЭД
	|	И ЭДПрисоединенныеФайлы.ПометкаУдаления = ЛОЖЬ";*/
			//Запрос.УстановитьПараметр("НомерЭД",       НомерЭД);
			//Запрос.УстановитьПараметр("НаправлениеЭД", Направление);
			//УстановитьПривилегированныйРежим(Истина);
			//Результат = Запрос.Выполнить().Выбрать();
			//ВозвращаемыйПараметр = Неопределено;
			if(true/*Результат.Следующий()*/)
			{
				//ВозвращаемыйПараметр = Результат.Ссылка;
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Обмен через каталог
		// Процедура предназначена для коррекции имени файла
		// замена некорректных символов на пробел
		//
		// Параметры
		//  СтрИмяФайла - Строка - Имя файла
		//

		public void СкорректироватьИмяФайла(/*СтрИмяФайла*/)
		{
			/*// Перечень запрещенных символов взят отсюда: http://support.microsoft.com/kb/100108/ru.
*/
			/*// При этом были объединены запрещенные символы для файловых систем FAT и NTFS.
*/
			//СтрИсключения = """ / \ [ ] : ; | = , ? * < >";
			//СтрИсключения = СтрЗаменить(СтрИсключения, " ", "");
			//СтрИмяФайла = СокрЛП(СтрИмяФайла);
		}
		// Создает пакет электронных документов.
		//
		// Параметры:
		//  МассивЭД - Массив ссылок на электронные документы, которые надо включить в пакет.
		//  ПризнакПодписи - булево, признак, что документы подписаны ЭЦП.
		//

		public object СоздатьДокументыПакетовЭД(/*МассивЭД, ПризнакПодписи*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ТЗ_ПЭД = Новый ТаблицаЗначений;
			//ТЗ_ПЭД.Колонки.Добавить("ПЭД");
			//ТЗ_ПЭД.Колонки.Добавить("Соглашение");
			//ТЗ_ПЭД.Колонки.Добавить("АдресРесурса");
			//МассивПодготовленныхКОтправкеЭД = Новый Массив;
			/*// Сформируем массив структур для обработки на клиенте
*/
			//МассивСтруктурПЭД = Новый Массив;
			//ОбновитьСтатусыЭД(МассивПодготовленныхКОтправкеЭД, ПризнакПодписи);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Формирование пакетов электронных документов
		// Только для внутреннего использования

		public void ПоместитьПакетЭДВКонверт(/*Конверт, АдресЗипКонтейнера*/)
		{
			/*// Так как теперь может быть несколько документов в одном пакете, надо проверять, есть ли
*/
			/*// уже присоединенные файлы к пакету. Если есть - ничего не делать.
*/
			//УстановитьПривилегированныйРежим(Истина);
			//Выборка = ПолучитьВыборкуЭДПоОтбору(Новый Структура("ВладелецФайла", Конверт));
			if(true/*ЗначениеЗаполнено(Выборка) И Выборка.Количество() > 0*/)
			{
			}
			//Файл = Новый Файл(АдресЗипКонтейнера);
			//ДвоичныеДанныеФайла = Новый ДвоичныеДанные(АдресЗипКонтейнера);
			//АдресВоВременномХранилище = ПоместитьВоВременноеХранилище(ДвоичныеДанныеФайла);
			/*ДобавленныйФайл = ПрисоединенныеФайлы.ДобавитьФайл(Конверт, Файл.ИмяБезРасширения, СтрЗаменить(Файл.Расширение,".", ""),
		ТекущаяДатаСеанса(), ТекущаяДатаСеанса(), АдресВоВременномХранилище, Неопределено, ,"ЭДПрисоединенныеФайлы");*/
		}
		////////////////////////////////////////////////////////////////////////////////
		// Распаковка пакетов электронных документов
		// Функция, добавляющая данные по распакованному пакету электронных документов.
		//
		// Параметры:
		//  ПакетЭД - ДокументСсылка.ПакетЭД, пакет электронных документов, по которому необходимо добавить данные.
		//  СтруктураДанныхПодписей - Структура, связывающая двоичные данные файла данных и двоичные данные файла электронной цифровой подписи.
		//  СтруктураДанных - Структура, связывающая имена файлов и их двоичные данные.
		//  СоответствиеФайлПараметры - Соответствие, связывающее имена файлов данных и имена файлов электронных цифровых подписей.
		//

		public object ДобавитьДанныеПоПакетуЭД(/*ПакетЭД,
								СтруктураДанныхПодписей,
								СтруктураДанных,
								СоответствиеФайлПараметры,
								ПапкаДляРаспаковки,
								ПапкаДляРасшифровки = "",
								ФлагОшибки = Ложь,
								ЕстьКриптосредствоНаКлиенте = Неопределено*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ЭтоПроизвольныйЭД = Ложь;
			if(true/*НЕ ЗначениеЗаполнено(ПапкаДляРасшифровки)*/)
			{
				//ПапкаДляРасшифровки = РабочийКаталог("Расшифровка", ПакетЭД.Ссылка.УникальныйИдентификатор());
			}
			if(true/*Найти(СтруктураДанных.ИмяФайла, "ИзвещениеОПолученииДокумента") > 0*/)
			{
				//ОбработатьИзвещениеОператора(ПакетЭД, СтруктураДанныхПодписей, СтруктураДанных, СоответствиеФайлПараметры);
			}
			//МассивДобавленныхФайлов = Новый Массив;
			/*// Попытаемся получить настройки криптографии.
*/
			/*// Если неудачно, значит средства криптографии не установлены на АРМ
*/
			if(true/*НЕ ЕстьКриптосредствоНаКлиенте = Истина И СтруктураДанныхПодписей.Количество() > 0
		И МенеджерКриптографии = Неопределено*/)
			{
				/*ТекстСообщения = НСтр("ru = 'Ошибка распаковки пакета:
		|%1
		|Пакет содержит электронные цифровые подписи. Для распаковки требуется наличие криптосредства на компьютере.'");*/
				//ТекстСообщения = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ТекстСообщения, ПакетЭД);
				if(true/*НЕ ЕстьКриптосредствоНаКлиенте = Неопределено*/)
				{
					//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(ТекстСообщения);
				}
				//ЗаписьЖурналаРегистрации(НСтр("ru = 'Распаковка пакета'"), УровеньЖурналаРегистрации.Информация, , , ТекстСообщения);
				//ФлагОшибки = Истина;
			}
			return null;
		}
		// Возвращает массив двоичных данных содержимого пакета электронных документов.
		//
		// Параметры:
		//  ПакетЭД - ДокументСсылка.ПакетЭД - исследуемый пакет электронных документов.
		//  ПараметрыШифрования - Структура, настройки шифрования, применимые к данному пакету электронных документов.
		//

		public object ВернутьМассивДвоичныхДанныхПакета(/*ПакетЭД, ПапкаДляРаспаковки = "", ПараметрыШифрования*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*ПакетЭД.СпособОбменаЭД = Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском*/)
			{
			}
			/*// Так как данный процесс потенциально порождает много ошибок и выполняется в цикле, возьмем его целиком в попытку-исключение,
*/
			/*// чтобы при ошибке в одном контейнере, остальные могли корректно распаковаться
*/
			//ФайлАрхива = "";
			//ФайлРасшифрованногоАрхива = "";
			if(true/*НЕ ЗначениеЗаполнено(ПапкаДляРаспаковки)*/)
			{
				//ПапкаДляРаспаковки = РабочийКаталог("Распаковка", ПакетЭД.Ссылка.УникальныйИдентификатор());
			}
			return null;
		}
		// Возвращает соответствие с двоичными данными файлов
		// и электронными цифровыми подписями к ним.
		//
		// Параметры:
		//  ИмяФайла - Строка, путь к файлу данных.
		//  РасшифрованныеДвоичныеДанные - ДвоичныеДанные, двоичные данные файла данных.
		//  СоответствиеФайлПараметры - Соответствие, связывает имена файлов данных и электронных цифровых подписей.
		//  ЭтоXMLФайл - Булево, признак того, что переданный файл является xml-файлом.
		//

		public object ПолучитьСоответствиеДанныхПодписей(/*ИмяФайла,
										ПапкаДляРаспаковки,
										РасшифрованныеДвоичныеДанные,
										СоответствиеФайлПараметры,
										ЭтоXMLФайл = Ложь*/)
		{
			//МассивВозврата = Новый Массив;
			//ФайлРасшифрованногоАрхива = ?(ЭтоXMLФайл, ТекущееИмяВременногоФайла("xml"), ТекущееИмяВременногоФайла("zip"));
			//РасшифрованныеДвоичныеДанные.Записать(ФайлРасшифрованногоАрхива);
			//РасшифрованныйФайлДанных = Новый Файл(ФайлРасшифрованногоАрхива);
			/*// Определить подпись к данному файлу, проверить подпись
*/
			//ПодписиФайлаДанных  = СоответствиеФайлПараметры.Получить(ИмяФайла).Подписи;
			//ДвоичныеДанныеФайлаДанных = Новый ДвоичныеДанные(РасшифрованныйФайлДанных.ПолноеИмя);
			if(true/*ПодписиФайлаДанных = Неопределено ИЛИ ПодписиФайлаДанных.Количество() = 0*/)
			{
				/*// Если подписей нет, тогда пока продолжаем, но, возможно, что это ошибка
*/
			}
			return null;
		}
		// Обрабатывает подтверждения документов, состоящие из электронно-цифровой подписи.
		//
		// Параметры:
		//  СоответствиеФайлПараметры - Соответствие, связывающее имена файлов данных и файлов электронных цифровых подписей к ним.
		//  ПакетЭДСсылка - ДокументСсылка.ПакетЭД, ссылка на пакет электронных документов, содержащий подтверждение.
		//

		public object ОбработатьПодтвержденияДокументовНаСервере(/*СоответствиеФайлПараметры, ПакетЭДСсылка, ПапкаДляРаспаковки*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//МассивВозврата = Новый Массив;
			//ПакетЭДОбъект = ПакетЭДСсылка.ПолучитьОбъект();
			/*// Попытаемся получить настройки криптографии.
*/
			/*// Подтверждением считаем подпись без файла (в соответствии - ключ с файлом подписи)
*/
			//ПакетЭДОбъект.СтатусПакета = Перечисления.СтатусыПакетовЭД.Распакован;
			//ПакетЭДОбъект.Записать();
			return null;
		}
		// Функция определяет настройки обмена ЭД
		// по источнику - документу базы данных или по ЭД
		//

		public object ОпределитьНастройкиОбменаЭДПоИсточнику(/*Источник,
											ВыводитьСообщения = Истина,
											ПараметрыСертификатов = Неопределено,
											ЭД = Неопределено,
											ВидЭД = Неопределено*/)
		{
			//ПараметрыЭД = ЭлектронныеДокументыВызовСервераСлужебный.ЗаполнитьПараметрыЭДПоИсточнику(Источник);
			if(true/*ЗначениеЗаполнено(ЭД)*/)
			{
				if(true/*ЗначениеЗаполнено(ЭД.СоглашениеЭД)*/)
				{
					//ПараметрыЭД.СоглашениеЭД = ЭД.СоглашениеЭД;
				}
				if(true/*НЕ ЗначениеЗаполнено(ПараметрыЭД.Контрагент)*/)
				{
					//ПараметрыЭД.Контрагент = ЭД.Контрагент;
				}
				if(true/*НЕ ЗначениеЗаполнено(ПараметрыЭД.Организация)*/)
				{
					//ПараметрыЭД.Организация = ЭД.Организация;
				}
				if(true/*НЕ ЗначениеЗаполнено(ПараметрыЭД.ВидЭД)*/)
				{
					//ПараметрыЭД.ВидЭД = ЭД.ВидЭД;
				}
			}
			/*// Заполним ВидЭД в случае непосредственного выбора пользователем.
*/
			if(true/*ЗначениеЗаполнено(ВидЭД)*/)
			{
				//ПараметрыЭД.ВидЭД = ВидЭД;
			}
			//Результат = ОпределитьНастройкиОбменаЭД(ПараметрыЭД, ПараметрыСертификатов);
			if(true/*Результат = Неопределено*/)
			{
				if(true/*ВыводитьСообщения*/)
				{
					//ПараметрыЭД.Удалить("ИмяРеквизитаОрганизации");
					//ПараметрыЭД.Удалить("ИмяРеквизитаКонтрагента");
					//СообщитьОбОтсутствииСоглашенияЭД(ПараметрыЭД, Источник);
				}
			}
			return null;
		}
		// Возвращает настройки обмена ЭД по ИД участников.
		//
		// Параметры
		//  ИДОрганизации – строка с ИД Отправителя,
		//  ИДКонтрагента - строка с ИД получателя
		//
		// Возвращаемое значение:
		//  Структуру параметров с настройками обмена
		//

		public object ПолучитьНастройкиОбменаЭДПоИД(/*ИДОрганизации, ИДКонтрагента, ТолькоСОператоромЭДО = Ложь*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//СтруктураВозврата = Неопределено;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	НастройкиОбменаЭД.Организация,
	|	НастройкиОбменаЭД.Контрагент,
	|	НастройкиОбменаЭД.Партнер КАК Партнер,
	|	НастройкиОбменаЭД.Ссылка КАК Основание,
	|	НастройкиОбменаЭД.АдресРесурсаКонтрагента,
	|	НастройкиОбменаЭД.АдресРесурсаОрганизации,
	|	ВЫБОР
	|		КОГДА НастройкиОбменаЭД.ЭтоИнтеркампани
	|			ТОГДА 2
	|		ИНАЧЕ 0
	|	КОНЕЦ КАК Приоритет
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД КАК НастройкиОбменаЭД
	|ГДЕ
	|	НастройкиОбменаЭД.ИдентификаторКонтрагента = &ИдентификаторКонтрагента
	|	И НастройкиОбменаЭД.ИдентификаторОрганизации = &ИдентификаторОрганизации
	|	И НЕ НастройкиОбменаЭД.ПометкаУдаления
	|	И НастройкиОбменаЭД.СтатусСоглашения = ЗНАЧЕНИЕ(Перечисление.СтатусыСоглашенийЭД.Действует)
	|	И НЕ &ТолькоСОператоромЭДО
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ
	|	СоглашениеЧерезОЭДО.Ссылка.Организация,
	|	УчастникиОбменовЭДЧерезОператоровЭДО.Участник,
	|	NULL,
	|	СоглашениеЧерезОЭДО.Ссылка,
	|	NULL,
	|	NULL,
	|	1
	|ИЗ
	|	РегистрСведений.УчастникиОбменовЭДЧерезОператоровЭДО КАК УчастникиОбменовЭДЧерезОператоровЭДО
	|		ЛЕВОЕ СОЕДИНЕНИЕ Справочник.СоглашенияОбИспользованииЭД КАК СоглашениеЧерезОЭДО
	|		ПО УчастникиОбменовЭДЧерезОператоровЭДО.СоглашениеОбИспользованииЭД = СоглашениеЧерезОЭДО.Ссылка
	|ГДЕ
	|	СоглашениеЧерезОЭДО.Ссылка.СтатусСоглашения = ЗНАЧЕНИЕ(Перечисление.СтатусыСоглашенийЭД.Действует)
	|	И НЕ СоглашениеЧерезОЭДО.Ссылка.ПометкаУдаления
	|	И УчастникиОбменовЭДЧерезОператоровЭДО.Идентификатор = &ИдентификаторКонтрагента
	|	И УчастникиОбменовЭДЧерезОператоровЭДО.Статус = ЗНАЧЕНИЕ(Перечисление.СтатусыУчастниковОбменаЭД.Присоединен)
	|	И СоглашениеЧерезОЭДО.ИдентификаторОрганизации = &ИдентификаторОрганизации
	|	И СоглашениеЧерезОЭДО.СпособОбменаЭД = ЗНАЧЕНИЕ(Перечисление.СпособыОбменаЭД.ЧерезОператораЭДОТакском)
	|
	|УПОРЯДОЧИТЬ ПО
	|	Приоритет";*/
			//Запрос.УстановитьПараметр("ИдентификаторОрганизации", ИДОрганизации);
			//Запрос.УстановитьПараметр("ИдентификаторКонтрагента", ИДКонтрагента);
			//Запрос.УстановитьПараметр("ТолькоСОператоромЭДО", 	  ТолькоСОператоромЭДО);
			//Выборка = Запрос.Выполнить().Выбрать();
			if(true/*Выборка.Следующий()*/)
			{
				//СтруктураВозврата = Новый Структура;
				//СтруктураВозврата.Вставить("Получатель",       ИДОрганизации);
				//СтруктураВозврата.Вставить("Отправитель",      ИДКонтрагента);
				//СтруктураВозврата.Вставить("Организация",      Выборка.Организация);
				//СтруктураВозврата.Вставить("Контрагент",       Выборка.Контрагент);
				//СтруктураВозврата.Вставить("Партнер",          Выборка.Партнер);
				//СтруктураВозврата.Вставить("Основание",        Выборка.Основание);
				//СтруктураВозврата.Вставить("АдресОтправителя", Выборка.АдресРесурсаКонтрагента);
				//СтруктураВозврата.Вставить("АдресПолучателя",  Выборка.АдресРесурсаОрганизации);
			}
			return null;
		}
		// Определяет признак шифрования и статус пакета электронных документов.
		//
		// Параметры:
		// МассивСсылокНаДокументы - массив ссылок на пакеты электронных документов, параметры которых надо определить.
		//

		public object ОпределитьШифрованиеИСтатус(/*Знач МассивСсылокНаДокументы*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//МассивВозврата = Новый Массив;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	ПакетЭД.Ссылка КАК СсылкаНаДокумент,
	|	ПакетЭД.Соглашение.СертификатОрганизацииДляРасшифровки КАК СертификатОрганизацииДляРасшифровки,
	|	ЭДПрисоединенныеФайлы.Ссылка,
	|	ПакетЭД.СтатусПакета
	|ИЗ
	|	Документ.ПакетЭД КАК ПакетЭД
	|		ЛЕВОЕ СОЕДИНЕНИЕ Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|		ПО (ЭДПрисоединенныеФайлы.ВладелецФайла = ПакетЭД.Ссылка)
	|ГДЕ
	|	ПакетЭД.Ссылка В(&МассивСсылок)
	|	И ПакетЭД.СпособОбменаЭД <> ЗНАЧЕНИЕ(Перечисление.СпособыОбменаЭД.ЧерезОператораЭДОТакском)";*/
			//Запрос.УстановитьПараметр("МассивСсылок", МассивСсылокНаДокументы);
			//ВыборкаПакеты = Запрос.Выполнить().Выбрать();
			while(true/*ВыборкаПакеты.Следующий()*/)
			{
				if(true/*НЕ ЗначениеЗаполнено(ВыборкаПакеты.Ссылка)*/)
				{
				}
				if(true/*ВыборкаПакеты.Количество() = 1 И  ВыборкаПакеты.СтатусПакета <> Перечисления.СтатусыПакетовЭД.КРаспаковке*/)
				{
					//ВызватьИсключение(Нстр("ru = 'Статус пакета отличен от значения ""К распаковке""! Обработка прервана...'"));
				}
				//ПараметрыДанных = ПрисоединенныеФайлы.ПолучитьДанныеФайла(ВыборкаПакеты.Ссылка);
				//ДвоичныеДанныеФайла = ПолучитьИзВременногоХранилища(ПараметрыДанных.СсылкаНаДвоичныеДанныеФайла);
				//ФайлАрхива = ТекущееИмяВременногоФайла("zip");
				//ДвоичныеДанныеФайла.Записать(ФайлАрхива);
				//ЗИПЧтение = Новый ЧтениеZipФайла(ФайлАрхива);
				//ПапкаДляРаспаковки = РабочийКаталог("Распаковка", ВыборкаПакеты.Ссылка.УникальныйИдентификатор());
				//ЗипЧтение.ИзвлечьВсе(ПапкаДляРаспаковки, РежимВосстановленияПутейФайловZIP.НеВосстанавливать);
				//ФайлыАрхива = НайтиФайлы(ПапкаДляРаспаковки, "*");
				//ЧтениеХМЛ = Новый ЧтениеXML;
				//ЧтениеХМЛ.ОткрытьФайл(ФайлИнформации.ПолноеИмя);
				//НашлиШифрование = Ложь;
				//Документ = Неопределено;
				//Зашифрован = Ложь;
				//Сертификат = "";
				while(true/*ЧтениеХМЛ.Прочитать()*/)
				{
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "НастройкиШифрования"*/)
					{
						//НашлиШифрование = Истина;
					}
					if(true/*Не НашлиШифрование*/)
					{
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "ДокументШифрования"*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//Документ = ЧтениеХМЛ.Значение;
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Зашифрован"*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//Зашифрован = Булево(ЧтениеХМЛ.Значение);
						//Сертификат = ВыборкаПакеты.СертификатОрганизацииДляРасшифровки;
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "СертификатШифрования"*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//Сертификат = ЧтениеХМЛ.Значение;
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.КонецЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "ДокументШифрования"*/)
					{
						//ПарольДоступа = СохраненныйПарольКСертификату(ВыборкаПакеты.СертификатОрганизацииДляРасшифровки);
						/*НоваяСтруктураМассива = Новый Структура("Документ, Зашифрован, Сертификат, ПарольДоступа",
					Документ, Зашифрован, Сертификат, ПарольДоступа);*/
						//МассивВозврата.Добавить(НоваяСтруктураМассива);
						//Документ = Неопределено;
						//Зашифрован = Ложь;
						//Сертификат = "";
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.КонецЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "НастройкиШифрования"*/)
					{
					}
				}
				/*;
		ЧтениеХМЛ.Закрыть();*/
				//УдалитьФайлы(ПапкаДляРаспаковки);
				//УдалитьФайлы(ФайлАрхива);
			}
			return null;
		}
		// Определяет, указано ли в настройках соглашения необходимость подписания для вида ЭД.
		//
		// Параметры:
		//  Соглашение    - ссылка на элемент справочника СоглашенияОбИспользованииЭД.
		//  ВидЭД         - значение перечисления ВидыЭД
		//  НаправлениеЭД - значение перечисления НаправленияЭД
		//
		// Возвращаемое значение:
		//  ИспользоватьЭЦП - Булево - истина или ложь
		//

		public object НеобходимоПодписать(/*ЭД*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//Реквизиты = ОбщегоНазначения.ПолучитьЗначенияРеквизитов(ЭД, "ВидЭД, НаправлениеЭД");
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СоглашенияОбИспользованииЭДВходящиеДокументы.ИспользоватьЭЦП
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД.ВходящиеДокументы КАК СоглашенияОбИспользованииЭДВходящиеДокументы
	|ГДЕ
	|	СоглашенияОбИспользованииЭДВходящиеДокументы.ВходящийДокумент = &ВидЭД
	|	И &НаправлениеЭД = ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Входящий)
	|	И СоглашенияОбИспользованииЭДВходящиеДокументы.Ссылка = &Ссылка
	|
	|ОБЪЕДИНИТЬ ВСЕ
	|
	|ВЫБРАТЬ
	|	СоглашенияОбИспользованииЭДИсходящиеДокументы.ИспользоватьЭЦП
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД.ИсходящиеДокументы КАК СоглашенияОбИспользованииЭДИсходящиеДокументы
	|ГДЕ
	|	СоглашенияОбИспользованииЭДИсходящиеДокументы.ИсходящийДокумент = &ВидЭД
	|	И (&НаправлениеЭД = ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Исходящий)
	|			ИЛИ &НаправлениеЭД = ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Интеркампани))
	|	И СоглашенияОбИспользованииЭДИсходящиеДокументы.Ссылка = &Ссылка";*/
			//Запрос.УстановитьПараметр("Ссылка",        ЭД.СоглашениеЭД);
			//Запрос.УстановитьПараметр("ВидЭД",         Реквизиты.ВидЭД);
			//Запрос.УстановитьПараметр("НаправлениеЭД", Реквизиты.НаправлениеЭД);
			//Результат = Запрос.Выполнить().Выбрать();
			//Результат.Следующий();
			return null;
		}
		// Определяет по параметрам, существует ли действующее соглашение
		//
		// Параметры:
		//  ПараметрыЭД - структура, содержащая параметры поиска соглашения
		//
		// Возвращаемое значение:
		//  Булево Истина или Ложь
		//

		public object ЕстьДействующееСоглашение(/*ПараметрыЭД*/)
		{
			//НастройкиОбмена = ОпределитьНастройкиОбменаЭД(ПараметрыЭД);
			//Возврат НЕ (НастройкиОбмена = Неопределено);
			return null;
		}
		// Только для внутреннего использования

		public object ПараметрыУчастникаОбменаЭДЧерезОператораЭДО(/*СоглашениеЧерезОЭДО, Участник*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//СтруктураВозврата = Неопределено;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СоглашениеЧерезОЭДО.Ссылка.Организация КАК Организация,
	|	УчастникиОбменовЭДЧерезОператоровЭДО.Участник КАК Контрагент,
	|	УчастникиОбменовЭДЧерезОператоровЭДО.Идентификатор КАК ИдентификаторКонтрагента,
	|	УчастникиОбменовЭДЧерезОператоровЭДО.ФорматФайловОбменаЭД,
	|	УчастникиОбменовЭДЧерезОператоровЭДО.Статус,
	|	УчастникиОбменовЭДЧерезОператоровЭДО.ДатаИзмененияСтатуса,
	|	СоглашениеЧерезОЭДО.ИдентификаторОрганизации
	|ИЗ
	|	РегистрСведений.УчастникиОбменовЭДЧерезОператоровЭДО КАК УчастникиОбменовЭДЧерезОператоровЭДО
	|		ЛЕВОЕ СОЕДИНЕНИЕ Справочник.СоглашенияОбИспользованииЭД КАК СоглашениеЧерезОЭДО
	|		ПО УчастникиОбменовЭДЧерезОператоровЭДО.СоглашениеОбИспользованииЭД = СоглашениеЧерезОЭДО.Ссылка
	|ГДЕ
	|	СоглашениеЧерезОЭДО.Ссылка = &СоглашениеЧерезОЭДО
	|	И УчастникиОбменовЭДЧерезОператоровЭДО.Участник = &Участник
	|	И СоглашениеЧерезОЭДО.СпособОбменаЭД = ЗНАЧЕНИЕ(Перечисление.СпособыОбменаЭД.ЧерезОператораЭДОТакском)";*/
			//Запрос.УстановитьПараметр("СоглашениеЧерезОЭДО", СоглашениеЧерезОЭДО);
			//Запрос.УстановитьПараметр("Участник", Участник);
			//Выборка = Запрос.Выполнить().Выбрать();
			/*СтруктураВозврата = Новый Структура("Организация, Контрагент, ИдентификаторОрганизации, ИдентификаторКонтрагента,
		|ФорматФайловОбменаЭД, Статус, ДатаИзмененияСтатуса");*/
			if(true/*Выборка.Следующий()*/)
			{
				//СтруктураВозврата.Вставить("Организация",              Выборка.Организация);
				//СтруктураВозврата.Вставить("Контрагент",               Выборка.Контрагент);
				//СтруктураВозврата.Вставить("ИдентификаторОрганизации", Выборка.ИдентификаторОрганизации);
				//СтруктураВозврата.Вставить("ИдентификаторКонтрагента", Выборка.ИдентификаторКонтрагента);
				//СтруктураВозврата.Вставить("ФорматФайловОбменаЭД",     Выборка.ФорматФайловОбменаЭД);
				//СтруктураВозврата.Вставить("Статус",                   Выборка.Статус);
				//СтруктураВозврата.Вставить("ДатаИзмененияСтатуса",     Выборка.ДатаИзмененияСтатуса);
			}
			return null;
		}
		// Только для внутреннего использования

		public object ОбработатьПодтвержденияДокументов(/*АдресКаталога, СоответствиеФайлПараметры, ПакетЭДОбъект*/)
		{
			//МассивВозврата = Новый Массив;
			/*// Попытаемся получить настройки криптографии.
*/
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Обработка электронных документов
		// Изменяет состояние версии электронного документа.
		//
		// Параметры:
		//  ЭлектронныйДокумент - СправочникСсылка.ЭДПрисоединенныеФайлы, Массив - электронные документы, версии которых надо обновить.
		//  ПринудительнаяСменаСостоянияВерсии - Булево, признак смены версии, несмотря на условия.
		//

		public void ОбновитьВерсиюЭД(/*ЭлектронныйДокумент, ПринудительнаяСменаСостоянияВерсии = Ложь*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*ТипЗнч(ЭлектронныйДокумент) = Тип("Массив")*/)
			{
			}
		}
		// Проверяет валидность подписей электронного документа
		// и заполняет реквизиты Статус и ДатаПроверкиПодписи в табличной части ЭлектронныеЦифровыеПодписи.
		//
		// Параметры:
		//  ЭД - СправочникСсылка.ЭДПрисоединенныеФайлы
		//  ВыводитьСообщения - Булево, требуется ли выводить сообщения .
		//

		public void ОпределитьСтатусыПодписей(/*ЭД, ВыводитьСообщения = Ложь*/)
		{
			//НастройкиКриптографии  = ЭлектроннаяЦифроваяПодпись.ПолучитьПерсональныеНастройкиРаботыСЭЦПСервер();
			//ПровайдерЭЦП           = НастройкиКриптографии.ПровайдерЭЦП;
			//ПутьМодуляКриптографии = НастройкиКриптографии.ПутьМодуляКриптографии;
			//ТипПровайдераЭЦП       = НастройкиКриптографии.ТипПровайдераЭЦП;
			//ДопИнформацияПоЭД = ПрисоединенныеФайлы.ПолучитьДанныеФайла(ЭД);
			//ДвоичныеДанныеДокумента = ПолучитьИзВременногоХранилища (ДопИнформацияПоЭД.СсылкаНаДвоичныеДанныеФайла);
			//ОбъектЭД = ЭД.ПолучитьОбъект();
			//ОбъектЭД.Записать();
		}
		// Помечает на удаление элементы справочника ЭДПрисоединенныеФайлы с отбором по владельцу
		//
		// Параметры:
		//  Ссылка -  ссылка на объект.
		//

		public void ПометитьНаУдалениеЭлектронныеДокументыПоВладельцу(/*Ссылка*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			/*ТекстЗапроса =
	"ВЫБРАТЬ
	|	Файлы.Ссылка КАК Ссылка,
	|	Файлы.Редактирует КАК Редактирует
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК Файлы
	|ГДЕ
	|	Файлы.ВладелецФайла = &ВладелецФайла
	|	И (Файлы.СтатусЭД = ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Сформирован)
	|			ИЛИ Файлы.СтатусЭД = ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.ПустаяСсылка))";*/
			//Запрос = Новый Запрос;
			//Запрос.Текст = ТекстЗапроса;
			//Запрос.УстановитьПараметр("ВладелецФайла", Ссылка);
			//Выборка = Запрос.Выполнить().Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				if(true/*Ссылка.ПометкаУдаления И НЕ Выборка.Редактирует.Пустая()*/)
				{
					/*ВызватьИсключение СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(
				НСтр("ru = '""%1"" не может быть удален, т.к. содержит файл ""%2"", занятый для редактирования.'"),
				Строка(Ссылка), Строка(Выборка.Ссылка));*/
				}
				//ФайлОбъект = Выборка.Ссылка.ПолучитьОбъект();
				//ФайлОбъект.Заблокировать();
				//ФайлОбъект.УстановитьПометкуУдаления(Ссылка.ПометкаУдаления);
			}
			//;;
		}
		// Рекурсивная процедура, получает все подчиненные электронные документы с любой глубиной вложенности.
		//
		// Параметры:
		//  МассивЭДВладельцев - массив ссылок на электронные документы владельцы (для текущей итерации - владелец выбираемых ЭД).
		//  МассивЭД - массив подчиненных электронных документов (с каждой итерацией увеличивается на количество найденных ЭД).
		//             Электронный документ - владелец добавляется в этот массив отдельно (до или после вызова данной процедуры).
		//

		public void ВыбратьПодчиненныеЭД(/*Знач МассивЭДВладельцев, МассивЭД*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	ЭДПрисоединенныеФайлы.Ссылка
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.ЭлектронныйДокументВладелец В (&МассивЭДВладельцев)
	|
	|СГРУППИРОВАТЬ ПО
	|	ЭДПрисоединенныеФайлы.Ссылка";*/
			//Запрос.УстановитьПараметр("МассивЭДВладельцев", МассивЭДВладельцев);
			//Результат = Запрос.Выполнить();
			if(true/*НЕ Результат.Пустой()*/)
			{
				//МассивЭДВладельцев = Результат.Выгрузить().ВыгрузитьКолонку("Ссылка");
				//ВыбратьПодчиненныеЭД(МассивЭДВладельцев, МассивЭД);
			}
		}
		// Только для внутреннего использования

		public void ПерезаполнитьДокументыИБПоЭД(/*СоответствиеВладельцевИЭД, КолОбработанных=0*/)
		{
		}
		// Только для внутреннего использования

		public void ЗаполнитьДокументИБПоЭД(/*СсылкаНаВладельца, СсылкаНаЭД, ДокЗаполнен =Ложь*/)
		{
			//ИмяФайлаДанных = ПолучитьИмяФайлаДанныхЭД(СсылкаНаЭД);
			if(true/*НЕ ЗначениеЗаполнено(ИмяФайлаДанных)*/)
			{
			}
			//ДанныеНаДиске = Новый Файл(ИмяФайлаДанных);
			if(true/*НЕ ДанныеНаДиске.Существует()*/)
			{
				/*ТекстСообщения = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(НСтр("ru = 'Файл данных не обнаружен: %1'"),
			ИмяФайлаДанных);*/
				//Сообщить(ТекстСообщения, СтатусСообщения.Важное);
			}
			//СтруктураПараметров = Новый Структура;
			//СтруктураПараметров.Вставить("ВладелецЭД",     СсылкаНаВладельца);
			//СтруктураПараметров.Вставить("ПолноеИмяФайла", ИмяФайлаДанных);
			//СтруктураЭД = ЭлектронныеДокументыФорматОбмена.РазобратьФайлДанных(СтруктураПараметров);
			//ДокЗаполнен = СтруктураЭД.Загружен;
		}
		// Выполняет последовательность действий для электронных документов.
		//
		// Параметры:
		//  МассивСсылокНаОбъект - Массив ссылок на электронные документы, для которых надо определить последовательность действий,
		//  КлиентскиеНастройкиКриптографии - Массив доступных сертификатов
		//  Действия - Строковое представление необходимых действий,
		//  ДопПараметры - Структура, дополнительные параметры, определяющие последовательность действий с электронными документами.
		//  ЭД - СправочникСсылка.ЭДПрисоединенныеФайлы, ссылка на элемент справочника ЭДПрисоединенныеФайлы
		//

		public object ВыполнитьДействияПоЭД(/*МассивСсылокНаОбъект,
								МассивСтруктурСертификатов,
								Действия,
								ДопПараметры = "",
								ЭД = Неопределено*/)
		{
			if(true/*НЕ ЕстьПравоОбработкиЭД(Истина)*/)
			{
			}
			if(true/*НЕ ИспользуетсяОбменЭД()*/)
			{
				//ТекстСообщения = ЭлектронныеДокументыПереопределяемый.ТекстСообщенияОНеобходимостиНастройкиСистемы("РаботаСЭД");
				//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(ТекстСообщения);
			}
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*НЕ (ЗначениеЗаполнено(ЭД) И (ЭД.НаправлениеЭД = Перечисления.НаправленияЭД.Входящий
		ИЛИ ЭД.ВидЭД = Перечисления.ВидыЭД.ТОРГ12Покупатель ИЛИ ЭД.ВидЭД = Перечисления.ВидыЭД.АктЗаказчик
		ИЛИ ЭтоСлужебныйДокумент(ЭД)))*/)
			{
				//ЭлектронныеДокументыПереопределяемый.ПроверитьГотовностьИсточников(МассивСсылокНаОбъект);
			}
			if(true/*МассивСсылокНаОбъект.Количество() = 0*/)
			{
			}
			//СтруктураВозврата = Новый Структура;
			//СоответствиеСертификатов = Новый Соответствие;
			//МассивНеобрабатываемыхОбъектов = Новый Массив;
			if(true/*ЭД = Неопределено И ЕстьДействие(Действия, "Сформировать")*/)
			{
				//НастройкиОбъектов = Новый Соответствие;
				if(true/*МассивСсылокНаОбъект.Количество() > 0*/)
				{
					//Запрос = Новый Запрос;
					/*ТекстЗапросаСоздатьЭД =
			"ВЫБРАТЬ
			|	МассивСсылок.ОбъектСсылка
			|ПОМЕСТИТЬ МассивСсылок
			|ИЗ
			|	&МассивСсылок КАК МассивСсылок
			|;
			|
			|////////////////////////////////////////////////////////////////////////////////
			|ВЫБРАТЬ
			|	МассивСсылок.ОбъектСсылка КАК ВладелецЭД
			|ИЗ
			|	МассивСсылок КАК МассивСсылок
			|		ЛЕВОЕ СОЕДИНЕНИЕ РегистрСведений.СостоянияЭД КАК СостоянияЭД
			|		ПО МассивСсылок.ОбъектСсылка = СостоянияЭД.СсылкаНаОбъект";*/
					if(true/*Действия = "СформироватьУтвердитьПодписатьОтправить"*/)
					{
						//ОпределитьНеобрабатываемыеОбъекты(НастройкиОбъектов, МассивНеобрабатываемыхОбъектов);
						/*Запрос.Текст = ТекстЗапросаСоздатьЭД + " ГДЕ
				|(СостоянияЭД.СсылкаНаОбъект ЕСТЬ NULL 
				|ИЛИ СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.НеСформирован))";*/
					}
					//МассивТипов = Новый Массив;
					//МассивТипов.Добавить(Тип("СправочникСсылка.СоглашенияОбИспользованииЭД"));
					//ТЗ_Ссылки = Новый ТаблицаЗначений;
					//КолонкаТЗ = ТЗ_Ссылки.Колонки.Добавить("ОбъектСсылка", Новый ОписаниеТипов(МассивТипов));
					//Запрос.УстановитьПараметр("МассивСсылок", ТЗ_Ссылки);
					//ТЗ_ЭД = Запрос.Выполнить().Выгрузить();
					//КолНовыхЭД = 0;
					if(true/*ТЗ_ЭД.Количество() > 0*/)
					{
						/*МассивНовыхЭД = СформироватьПрисоединенныеФайлы(ТЗ_ЭД.ВыгрузитьКолонку("ВладелецЭД"),
					НастройкиОбъектов, ДопПараметры);*/
						//КолНовыхЭД = МассивНовыхЭД.Количество();
					}
					//СтруктураВозврата.Вставить("КоличествоНовыхЭД", КолНовыхЭД);
					if(true/*Действия = "Сформировать"*/)
					{
						//СтруктураВозврата.Вставить("МассивНовыхЭД", МассивНовыхЭД);
					}
				}
			}
			if(true/*МассивСсылокНаОбъект.Количество() = 0*/)
			{
				/*// не найдено действующее соглашение
*/
			}
			//Запрос = Новый Запрос;
			/*ТекстЗапроса =
	"ВЫБРАТЬ
	|	СостоянияЭД.СсылкаНаОбъект КАК ВладелецЭД,
	|	ЕСТЬNULL(ПрисоединенныеФайлы.Ссылка, ЗНАЧЕНИЕ(Справочник.ЭДПрисоединенныеФайлы.ПустаяСсылка)) КАК СсылкаНаЭД,
	|	ПрисоединенныеФайлы.СтатусЭД,
	|	ПрисоединенныеФайлы.ВидЭД,
	|	ПрисоединенныеФайлы.СоглашениеЭД КАК Соглашение
	|ИЗ
	|	РегистрСведений.СостоянияЭД КАК СостоянияЭД
	|		ЛЕВОЕ СОЕДИНЕНИЕ Справочник.ЭДПрисоединенныеФайлы КАК ПрисоединенныеФайлы
	|		ПО (ПрисоединенныеФайлы.Ссылка = СостоянияЭД.ЭлектронныйДокумент)
	|ГДЕ
	|	СостоянияЭД.СсылкаНаОбъект В(&МассивСсылок)";*/
			//Запрос.УстановитьПараметр("МассивСсылок", МассивСсылокНаОбъект);
			if(true/*ЕстьДействие(Действия, "Утвердить")*/)
			{
				if(true/*Не ЗначениеЗаполнено(ЭД)*/)
				{
					/*ДопУсловие = " И (НЕ ПрисоединенныеФайлы.Ссылка ЕСТЬ NULL) 
			|	И (ПрисоединенныеФайлы.СтатусЭД=ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Сформирован)
			|	ИЛИ ПрисоединенныеФайлы.СтатусЭД=ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Получен)
			|	ИЛИ ПрисоединенныеФайлы.СтатусЭД=ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Утвержден))";*/
					if(true/*МассивНеобрабатываемыхОбъектов.Количество() > 0*/)
					{
						//ДопУсловие = ДопУсловие + " И НЕ(ПрисоединенныеФайлы.Ссылка В (&МассивНеобрабатываемыхОбъектов))";
						//Запрос.УстановитьПараметр("МассивНеобрабатываемыхОбъектов", МассивНеобрабатываемыхОбъектов);
					}
					//Запрос.Текст = ТекстЗапроса + ДопУсловие;
					//ТЗ_ЭД = Запрос.Выполнить().Выгрузить();
				}
				//КолУтвержденныхЭД = 0;
				//КолУтвержденныхРанее = 0;
				//СтруктураВозврата.Вставить("КоличествоУтвержденныхЭД", КолУтвержденныхЭД);
			}
			if(true/*ЕстьДействие(Действия, "Подписать")*/)
			{
				if(true/*Не ЗначениеЗаполнено(ЭД)*/)
				{
					/*ДопУсловие = " И (НЕ ПрисоединенныеФайлы.Ссылка ЕСТЬ NULL) И (ПрисоединенныеФайлы.СтатусЭД=ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.Утвержден)
			|	ИЛИ ПрисоединенныеФайлы.СтатусЭД=ЗНАЧЕНИЕ(Перечисление.СтатусыЭД.ЧастичноПодписан))";*/
					if(true/*МассивНеобрабатываемыхОбъектов.Количество() > 0*/)
					{
						//ДопУсловие = ДопУсловие + " И НЕ(ПрисоединенныеФайлы.Ссылка В (&МассивНеобрабатываемыхОбъектов))";
						//Запрос.УстановитьПараметр("МассивНеобрабатываемыхОбъектов", МассивНеобрабатываемыхОбъектов);
					}
					//Запрос.Текст = ТекстЗапроса + ДопУсловие;
					//ТЗ_ЭД = Запрос.Выполнить().Выгрузить();
				}
				//ТЗ_ЭД.Колонки.Добавить("Подписывать");
				//ТЗ_ЭД.Колонки.Добавить("Сертификат");
				//КолСтрокТЗ = ТЗ_ЭД.Количество();
				//ИндексТекСтроки = 0;
				while(true/*ИндексТекСтроки < КолСтрокТЗ*/)
				{
					//ТекСтрока = ТЗ_ЭД[ИндексТекСтроки];
					if(true/*ЗначениеЗаполнено(НастройкиОбъектов)*/)
					{
						//НастройкиОбменаЭД = НастройкиОбъектов.Получить(ТекСтрока.ВладелецЭД);
					}
					if(true/*НЕ ЗначениеЗаполнено(НастройкиОбменаЭД)*/)
					{
						/*// нет обмена
*/
						//ИндексТекСтроки = ИндексТекСтроки + 1;
					}
					//ТекСтрока.Подписывать = Ложь;
					/*ТекстОшибки = НСтр("ru = 'Нет действующего сертификата ЭЦП для организации <%1>, по виду документов <%2>.
			|Перейдите в настройки обмена, задайте вид документа <%2> для действующего сертификата организации <%1>.'");*/
					/*// В настройках задано требование подписать и еще не подписывали
*/
					/*// для исходящих и входящих документов.
*/
					if(true/*НастройкиОбменаЭД.Подписывать И (ТекСтрока.СтатусЭД = Перечисления.СтатусыЭД.Утвержден
				ИЛИ ТекСтрока.СтатусЭД = Перечисления.СтатусыЭД.ЧастичноПодписан)*/)
					{
						//ТекСтрока.Подписывать = Истина;
						if(true/*ТекСтрока.СсылкаНаЭД.НаправлениеЭД = Перечисления.НаправленияЭД.Интеркампани*/)
						{
							/*// Для интеркампани добавляем два сертификата для подписи ЭД
*/
							/*// (если ЭД ранее не был подписан текущим сертификатом).
*/
						}
					}
					//ТекСтрока.Соглашение = НастройкиОбменаЭД.СоглашениеЭД;
					//ИндексТекСтроки = ИндексТекСтроки + 1;
				}
				/*;
		
		МассивСертификатов = Новый Массив;*/
				//ВремТЗ = ТЗ_ЭД.Скопировать(, "Сертификат");
				//ВремТЗ.Свернуть("Сертификат");
				//СтруктураВозврата.Вставить("МассивСертификатов", МассивСертификатов);
			}
			if(true/*ЕстьДействие(Действия, "Отправить")*/)
			{
				if(true/*ЗначениеЗаполнено(ЭД)*/)
				{
					//ТЗ_ЭД = ТаблицаПоЭД(ЭД);
					if(true/*(ЭД.ВидЭД = Перечисления.ВидыЭД.ТОРГ12Продавец ИЛИ ЭД.ВидЭД = Перечисления.ВидыЭД.АктИсполнитель)
				И ЭД.НаправлениеЭД = Перечисления.НаправленияЭД.Входящий*/)
					{
						//ТЗ_ЭД.Удалить(ТЗ_ЭД[0]);
					}
				}
				//ТЗ_ЭД.Колонки.Добавить("Подписывать");
				//ТЗ_ЭД.Колонки.Добавить("Сертификат");
				if(true/*Действия = "Отправить"*/)
				{
				}
				if(true/*(ЕстьДействие(Действия, "Утвердить") И (КолУтвержденныхЭД > 0 ИЛИ КолУтвержденныхРанее > 0))
			ИЛИ Действия = "Отправить"*/)
				{
					//МассивСоглашений = Новый Массив;
					//ВремТЗ = ТЗ_ЭД.Скопировать(, "Соглашение");
					//ВремТЗ.Свернуть("Соглашение");
					//СтруктураВозврата.Вставить("МассивСоглашений", МассивСоглашений);
				}
			}
			return null;
		}
		// Обрабатывает входящий произвольный документ.
		//
		// Параметры:
		//  ПапкаДляРаспаковки - Строка, путь к папке, куда будет помещено содержимое произвольного электронного документа,
		//  ПараметрШифрования - Булево, признак шифрования произвольного электронного документа,
		//  МассивФайловДанных - Массив, список документов, приложенных к произвольному электронному документу,
		//  МенеджерКриптографии - Менеджер криптографии, предназначенный для дешифрования произвольного электронного документа,
		//  МенеджерКриптографииПодписи - менеджер криптографии, предназначенный для проверки подписи вложений произвольного электронного документа,
		//  ПакетЭДОбъект - объект ИБ, содержащий в себе произвольный электронный документ,
		//  СоответствиеФайлПараметры - соответствие, определяющее наличие вложений и подписей к ним в произвольном электронном документе.
		//

		public object ОбработатьВходящийПроизвольныйЭД(/*ПапкаДляРаспаковки,
										ПараметрыШифрования,
										МассивФайловДанных,
										МенеджерКриптографии,
										МенеджерКриптографииПодписи,
										ПакетЭДОбъект,
										СоответствиеФайлПараметры*/)
		{
			//ДокументСообщение = Неопределено;
			if(true/*МассивФайловДанных.Количество() > 0*/)
			{
				//СтрокаСообщения = СоответствиеФайлПараметры.Получить("Текст");
			}
			//ПакетЭДОбъект.СтатусПакета = Перечисления.СтатусыПакетовЭД.Распакован;
			//ПакетЭДОбъект.Записать();
			return null;
		}
		// Получает текстовое представление электронного документа.
		//
		// Параметры:
		//  СсылкаНаЭД - Ссылка на электронный документ, текстовое представление которого необходимо получить.
		//

		public object ПолучитьПредставлениеЭД(/*СсылкаНаЭД*/)
		{
			/*Версия = ?(ЗначениеЗаполнено(СсылкаНаЭД.ДатаФормированияЭДОтправителем), СсылкаНаЭД.ДатаФормированияЭДОтправителем,
		СсылкаНаЭД.НомерВерсииЭД);*/
			//ТекстВерсии = ?(ЗначениеЗаполнено(Версия), " (версия " + Версия + ")", "");
			/*ТекстДаты = ?(ЗначениеЗаполнено(СсылкаНаЭД.ДатаДокументаОтправителя),
		" от " + Формат(СсылкаНаЭД.ДатаДокументаОтправителя, "ДФ=dd.MM.yyyy"), "");*/
			if(true/*СсылкаНаЭд.ВидЭД = Перечисления.ВидыЭД.КаталогТоваров ИЛИ СсылкаНаЭд.ВидЭД = Перечисления.ВидыЭД.ПрайсЛист*/)
			{
				//Представление = "" + СсылкаНаЭД.ВидЭД + ТекстДаты + ТекстВерсии;
			}
			return null;
		}
		// Определяет состояние версии электронного документа на основании статуса текущего электронного документа.
		//
		// Параметры:
		//  СсылкаНаЭД - СправочникСсылка.ЭДПрисоединенныеФайлы, ссылка на электронный документ.
		//

		public object ОпределитьСостояниеВерсииПоСтатусуЭД(/*СсылкаНаЭД*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ВозвращаемоеЗначение = Неопределено;
			if(true/*СсылкаНаЭД = Неопределено*/)
			{
				//ВозвращаемоеЗначение = Перечисления.СостоянияВерсийЭД.НеСформирован;
			}
			return null;
		}
		// Определяет, все ли установленные на ЭД подписи являются валидными
		//
		// Параметры:
		// ЭД - СправочникСсылка.ЭДПрисоединенныеФайлы, ссылка на электронный документ.
		//

		public object УстановленныеПодписиВалидны(/*ЭД*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ РАЗРЕШЕННЫЕ
	|	ЭДПрисоединенныеФайлыЭлектронныеЦифровыеПодписи.ПодписьВерна
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы.ЭлектронныеЦифровыеПодписи КАК ЭДПрисоединенныеФайлыЭлектронныеЦифровыеПодписи
	|ГДЕ
	|	ЭДПрисоединенныеФайлыЭлектронныеЦифровыеПодписи.Ссылка = &Ссылка
	|	И НЕ ЭДПрисоединенныеФайлыЭлектронныеЦифровыеПодписи.ПодписьВерна";*/
			//Запрос.УстановитьПараметр("Ссылка", ЭД.Ссылка);
			//Результат = Запрос.Выполнить().Выбрать();
			if(true/*Результат.Количество()>0*/)
			{
				/*ШаблонТекста = НСтр("ru = 'Обработка электронного документа %1.
		|Документ не обработан, так как содержит невалидные подписи.'");*/
				//Текст = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ШаблонТекста, ЭД);
				//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(Текст);
			}
			return null;
		}
		// Только для внутреннего использования

		public object ИспользуетсяОбменЭД(/**/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Обработка ошибок
		// Только для внутреннего использования

		public void ЗаписатьОшибкуПоЭД(/*ВидОперации, ТекстОшибки*/)
		{
			//ШаблонСообщения = НСтр("ru = 'Выполнение операции: %1.'");
			//ТекстСообщения = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ШаблонСообщения, ВидОперации);
			//ЗаписьЖурналаРегистрации(ТекстСообщения, УровеньЖурналаРегистрации.Ошибка, , , ТекстОшибки);
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с типами объектов
		// Определяет тип объекта по текстовому представлению.
		//
		// Параметры:
		//  ОписаниеТипаОбъекта - строка, текстовое представление типа объекта.
		//

		public object ОпределитьТипОбъекта(/*ОписаниеТипаОбъекта*/)
		{
			//ТипОбъекта = Неопределено;
			//ИмяПрикладногоСправочника = ЭлектронныеДокументыПовтИсп.ПолучитьИмяПрикладногоСправочника(ОписаниеТипаОбъекта);
			if(true/*ЗначениеЗаполнено(ИмяПрикладногоСправочника)*/)
			{
				//ТипОбъекта = "СправочникСсылка." + ИмяПрикладногоСправочника;
			}
			return null;
		}
		// Получает имя владельца справочника НоменклатураПоставщика.
		//
		// Возвращаемое значение:
		//  ИмяСправочника - строковое имя владельца.
		//

		public object ПолучитьИмяРеквизитаВладельцаНоменклатурыПоставщиков(/**/)
		{
			//ИмяРеквизитаВладельца = Неопределено;
			//ЭлектронныеДокументыПереопределяемый.ОпределитьИмяРеквизитаВладельцаНоменклатурыПоставщиков(ИмяРеквизитаВладельца);
			if(true/*ИмяРеквизитаВладельца = Неопределено*/)
			{
				/*// не задано соответствие
*/
				//ТекстСообщения = НСтр("ru = 'В коде прикладного решения необходимо указать имя реквизита для владельца номенклатуры поставщиков.'");
				/*ЗаписьЖурналаРегистрации(ЭлектронныеДокументыСлужебный.ТекстовоеПредставлениеПодсистемыДляЖурналаРегистрации(),
			УровеньЖурналаРегистрации.Предупреждение, , , ТекстСообщения);*/
				//ИмяРеквизитаВладельца = "";
			}
			return null;
		}
		// Определяет, является ли параметр ссылкой на номенклатуру
		//
		// Параметры:
		//  СсылкаНаОбъект - любой объект.
		//
		// Возвращаемое значение:
		//  Булево - Истина, если это ссылка на элемент справочника Номенклатура ИЛИ НоменклатураПоставщиков
		//

		public object ЭтоНоменклатура(/*СсылкаНаОбъект*/)
		{
			//Результат = Ложь;
			//Результат = ТипЗнч(СсылкаНаОбъект) = Тип(ОпределитьТипОбъекта("Номенклатура"));
			if(true/*ОпределитьТипОбъекта("НоменклатураПоставщиков") <> Неопределено*/)
			{
				//Результат = ТипЗнч(СсылкаНаОбъект) = Тип(ОпределитьТипОбъекта("НоменклатураПоставщиков"));
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с журналом регистрации
		// Записывает в журнал регистрации событие записи ЭД.
		//
		// Параметры:
		//  СсылкаНаЭД - ссылка на элемент справочника ЭДПрисоединенныеФайлы.
		//

		public void ЗаписатьСобытиеЖурналаРегистрацииПоОбменуЭД(/*СсылкаНаЭД*/)
		{
			if(true/*ТипЗнч(СсылкаНаЭД) = Тип("СправочникСсылка.ЭДПрисоединенныеФайлы")*/)
			{
				//НачатьТранзакцию();
				//Блокировка = Новый БлокировкаДанных;
				//ЭлементБлокировки = Блокировка.Добавить("РегистрСведений.ЖурналСобытийЭД");
				//ЭлементБлокировки.УстановитьЗначение("ПрисоединенныйФайл", СсылкаНаЭД);
				//Блокировка.Заблокировать();
				//Запрос = Новый Запрос;
				/*Запрос.Текст =
		"ВЫБРАТЬ
		|	ЕСТЬNULL(МАКСИМУМ(ЖурналСобытийЭД.НомерЗаписи), 0) + 1 КАК НомерЗаписи
		|ИЗ
		|	РегистрСведений.ЖурналСобытийЭД КАК ЖурналСобытийЭД
		|ГДЕ
		|	ЖурналСобытийЭД.ПрисоединенныйФайл = &ПрисоединенныйФайл";*/
				//Запрос.УстановитьПараметр("ПрисоединенныйФайл", СсылкаНаЭД);
				//НомерЗаписи = Запрос.Выполнить().Выгрузить()[0].НомерЗаписи;
				//МенджерЗаписи                    = РегистрыСведений.ЖурналСобытийЭД.СоздатьМенеджерЗаписи();
				//МенджерЗаписи.ПрисоединенныйФайл = СсылкаНаЭД;
				//МенджерЗаписи.НомерЗаписи        = НомерЗаписи;
				//МенджерЗаписи.ВладелецЭД         = СсылкаНаЭД.ВладелецФайла;
				//МенджерЗаписи.СтатусЭД           = СсылкаНаЭД.СтатусЭД;
				//МенджерЗаписи.Дата               = Формат(СсылкаНаЭД.ДатаИзмененияСтатусаЭД, "ДЛФ=");
				//МенджерЗаписи.Пользователь       = ПараметрыСеанса.ТекущийПользователь;
				//МенджерЗаписи.Записать();
				//ЗафиксироватьТранзакцию();
			}
		}
		// Возвращает текстовое представление для события в журнале регистрации.
		//
		// Параметры:
		//  СсылкаНаОбъект - Ссылка на объект ИБ, представление события для которого необходимо получить.
		//

		public object ТекстовоеПредставлениеСобытияДляЖурналаРегистрации(/*СсылкаНаОбъект*/)
		{
			//ТекстПредставления = "";
			//ЭлектронныеДокументыПереопределяемый.ТекстовоеПредставлениеСобытияДляЖурналаРегистрации(СсылкаНаОбъект, ТекстПредставления);
			if(true/*НЕ ЗначениеЗаполнено(ТекстПредставления)*/)
			{
				if(true/*ТипЗнч(СсылкаНаОбъект) = Тип("СправочникСсылка.СоглашенияОбИспользованииЭД")*/)
				{
					//Текст = НСтр("ru ='Соглашение об использовании электронных документов %1.'");
					//ТекстПредставленияВладельца = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(Текст, СсылкаНаОбъект.Код);
				}
				if(true/*НЕ ЗначениеЗаполнено(ТекстПредставленияВладельца)*/)
				{
					//ТекстПредставленияВладельца = Строка(СсылкаНаОбъект);
				}
				/*ТекстПредставления = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(НСтр("ru = '%1 %2'"),
			ТекстовоеПредставлениеПодсистемыДляЖурналаРегистрации(), ТекстПредставленияВладельца);*/
			}
			return null;
		}
		// Возвращает текстовое представление заголовка события по подсистеме.
		//

		public object ТекстовоеПредставлениеПодсистемыДляЖурналаРегистрации(/**/)
		{
			//Возврат НСтр("ru = 'Обмен ЭД.'");
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Прочие
		// Определяет имя файла электронного документа.
		//
		// Параметры:
		//  ВидЭД - Вид электронного документа, перечисление.
		//

		public object ОпределитьИмяФайлаЭД(/*ВидЭД, СсылкаНаОбъект*/)
		{
			if(true/*ВидЭД = Перечисления.ВидыЭД.СчетФактура
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ТОРГ12
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ТОРГ12Продавец
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ТОРГ12Покупатель
		ИЛИ ВидЭД = Перечисления.ВидыЭД.АктВыполненныхРабот
		ИЛИ ВидЭД = Перечисления.ВидыЭД.АктИсполнитель
		ИЛИ ВидЭД = Перечисления.ВидыЭД.АктЗаказчик
		ИЛИ ВидЭД = Перечисления.ВидыЭД.СчетНаОплату
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ЗаказТовара
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ОтветНаЗаказ
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ПрайсЛист
		ИЛИ ВидЭД = Перечисления.ВидыЭД.КаталогТоваров
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ОтчетОПродажахКомиссионногоТовара
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ОтчетОСписанииКомиссионногоТовара
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ПередачаТоваровМеждуОрганизациями
		ИЛИ ВидЭД = Перечисления.ВидыЭД.ВозвратТоваровМеждуОрганизациями*/)
			{
				//СтруктураПараметров = Новый Структура;
				//СтруктураПараметров.Вставить("НомерВладельца",СсылкаНаОбъект.Номер);
				//СтруктураПараметров.Вставить("ДатаВладельца",СсылкаНаОбъект.Дата);
				//СтруктураПараметров.Вставить("ВерсияЭД",НомерВерсииЭДПоВладельцу(СсылкаНаОбъект));
				//СтрокаИмени = ОпределитьПредставлениеЭД(ВидЭД, СтруктураПараметров)+".xml";
			}
			//СтрокаИмени = КорректноеИмяФайла(СтрокаИмени, Истина);
			return null;
		}
		// Определяет представление электронного документа.
		//
		// Параметры:
		//  ВидЭД - Вид электронного документа, перечисление.
		//  СтруктураПараметров: НомерВладельца, ДатаВладельца, ВерсияЭД.
		//

		public object ОпределитьПредставлениеЭД(/*ВидЭД, СтруктураПараметров*/)
		{
			//ТекстВидЭД = "";
			//ТекстНомера = "";
			//ТекстДаты = "";
			//ТекстВерсии = "";
			//ЗначениеСвойства = Неопределено;
			if(true/*СтруктураПараметров.Свойство("НомерВладельца", ЗначениеСвойства) И ЗначениеЗаполнено(ЗначениеСвойства)*/)
			{
				//ТекстНомера = "_" + ЗначениеСвойства;
			}
			if(true/*СтруктураПараметров.Свойство("ДатаВладельца", ЗначениеСвойства) И ЗначениеЗаполнено(ЗначениеСвойства)*/)
			{
				//ТекстДаты = "_" + Формат(ЗначениеСвойства, "ДФ=yyyy-MM-dd");
			}
			if(true/*ВидЭД <> Перечисления.ВидыЭД.СчетФактура И ВидЭД <> Перечисления.ВидыЭД.ИзвещениеОПолучении
		И ВидЭД <> Перечисления.ВидыЭД.Подтверждение И ВидЭД <> Перечисления.ВидыЭД.УведомлениеОбУточнении
		И СтруктураПараметров.Свойство("ВерсияЭД", ЗначениеСвойства) И ЗначениеЗаполнено(ЗначениеСвойства)*/)
			{
				//ТекстВерсии = НСтр("ru = ' (версия %1)'");
				//ТекстВерсии = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ТекстВерсии, ЗначениеСвойства);
			}
			if(true/*ВидЭД = Перечисления.ВидыЭД.СчетФактура*/)
			{
				//ТекстВидЭД = "СФ";
			}
			//ПредставлениеЭД = ТекстВидЭД + ТекстНомера + ТекстДаты + ТекстВерсии;
			return null;
		}
		// Функция предназначена для проверки имени файла на наличие некорректных символов
		// Алгоритм взят с небольшими изменениями из процедуры клиентского общего модуля "ФайловыеФункции"
		//
		// Параметры:
		//  СтрИмяФайла - Строка - проверяемое имя файла
		//  ФлУдалятьНекорректные - Булево - удалять или нет некорректные символы из переданной строки
		// Возвращаемое значение:
		//  Строка - имя файла
		//

		public object КорректноеИмяФайла(/*СтрИмяФайла, ФлУдалятьНекорректные = Ложь*/)
		{
			/*// Перечень запрещенных символов взят отсюда: http://support.microsoft.com/kb/100108/ru
*/
			/*// при этом были объединены запрещенные символы для файловых систем FAT и NTFS
*/
			//СтрИсключения = """ / \ [ ] : ; | = , ? * < >";
			//СтрИсключения = СтрЗаменить(СтрИсключения, " ", "");
			//Результат = Истина;
			if(true/*Не Результат*/)
			{
				/*Текст = НСтр("ru = 'В имени файла не должно быть следующих символов: %1
		|Имя файла: %2'");*/
				//ТекстОшибки = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(Текст, СтрИсключения, СтрИмяФайла);
				//ВызватьИсключение ТекстОшибки;
			}
			return null;
		}
		// Проверяет, является ли переданный в параметре ЭД служебным или нет.
		//

		public object ЭтоСлужебныйДокумент(/*ЭлектронныйДокумент*/)
		{
			if(true/*ЗначениеЗаполнено(ЭлектронныйДокумент.ТипЭлементаВерсииЭД)*/)
			{
				/*ВозвращаемоеЗначение = НЕ (ЭлектронныйДокумент.ТипЭлементаВерсииЭД = Перечисления.ТипыЭлементовВерсииЭД.ПервичныйЭД
			ИЛИ ЭлектронныйДокумент.ТипЭлементаВерсииЭД = Перечисления.ТипыЭлементовВерсииЭД.ЭСФ);*/
			}
			return null;
		}
		// Проверяет, умещаются ли переданные табличные документы
		// на страницу при печати.
		//
		// Параметры
		//  ТабДокумент        – Табличный документ
		//  ВыводимыеОбласти   – Массив из проверяемых таблиц или табличный документ
		//  РезультатПриОшибке - Какой возвращать результат при возникновении ошибки
		//
		// Возвращаемое значение:
		//  Булево – умещаются или нет переданные документы
		//

		public object ПроверитьВыводТабличногоДокумента(/*ТабДокумент,
										ВыводимыеОбласти,
										РезультатПриОшибке = Истина*/)
		{
			return null;
		}
		// Только для внутреннего использования

		public object МассивСпособовОбменаЭД(/*ФлагПрямогоОбмена = Истина*/)
		{
			//СпособыОЭД = Новый Массив;
			if(true/*ФлагПрямогоОбмена*/)
			{
				//СпособыОЭД.Добавить(Перечисления.СпособыОбменаЭД.ЧерезКаталог);
				//СпособыОЭД.Добавить(Перечисления.СпособыОбменаЭД.ЧерезЭлектроннуюПочту);
			}
			return null;
		}
		// Только для внутреннего использования

		public object ЭтоПрямойОбменЭД(/*СпособОбменаЭД*/)
		{
			//ФлагПрямогоОбменаЭД = Истина;
			//СпособыПрямогоОЭД = МассивСпособовОбменаЭД(Истина);
			if(true/*СпособыПрямогоОЭД.Найти(СпособОбменаЭД) = Неопределено*/)
			{
				//ФлагПрямогоОбменаЭД = Ложь;
			}
			return null;
		}
		// Только для внутреннего использования

		public object РабочийКаталог(/*Знач ВидОбработки = "", КлючУникальности = ""*/)
		{
			//Подкаталог = "";
			if(true/*ЗначениеЗаполнено(ВидОбработки)*/)
			{
				//Подкаталог = КорректноеИмяФайла(ВидОбработки, Истина) + "\";
			}
			//ИмяКаталога = ТекущийКаталогВременныхФайлов() + Подкаталог + КлючУникальности + "\";
			//КаталогНаДиске = Новый Файл(ИмяКаталога);
			if(true/*КаталогНаДиске.Существует()*/)
			{
				//УдалитьФайлы(КаталогНаДиске, "*");
			}
			//УдалитьЛишнийСлэшВПути(ИмяКаталога);
			return null;
		}
		// Только для внутреннего использования

		public object ПолучитьДопустимыйСтатусЭД(/*НовыйСтатус, СсылкаНаЭД*/)
		{
			//ТекущийСтатус = Неопределено;
			if(true/*ЗначениеЗаполнено(СсылкаНаЭД)*/)
			{
				if(true/*ТипЗнч(СсылкаНаЭД) = Тип("ДокументСсылка.ПроизвольныйЭД")*/)
				{
					//ТекущийСтатус = СсылкаНаЭД.СтатусДокумента;
				}
				if(true/*НовыйСтатус = Перечисления.СтатусыЭД.Отклонен ИЛИ НовыйСтатус = Перечисления.СтатусыЭД.ОтклоненПолучателем
			ИЛИ НЕ ЗначениеЗаполнено(ТекущийСтатус) ИЛИ НовыйСтатус = Перечисления.СтатусыЭД.ОшибкаПередачи*/)
				{
					//ТекущийСтатус = НовыйСтатус;
				}
			}
			return null;
		}
		// Только для внутреннего использования

		public object ВернутьМассивСтатусовЭД(/*НастройкиОбмена*/)
		{
			//МассивСтатусов = Новый Массив;
			if(true/*ЗначениеЗаполнено(НастройкиОбмена)*/)
			{
				if(true/*НастройкиОбмена.Направление = Перечисления.НаправленияЭД.Исходящий*/)
				{
					if(true/*НастройкиОбмена.ВидЭД = Перечисления.ВидыЭД.ИзвещениеОПолучении
				ИЛИ НастройкиОбмена.ВидЭД = Перечисления.ВидыЭД.УведомлениеОбУточнении*/)
					{
						//МассивСтатусов.Добавить(Перечисления.СтатусыЭД.Сформирован);
						//МассивСтатусов.Добавить(Перечисления.СтатусыЭД.Утвержден);
						//МассивСтатусов.Добавить(Перечисления.СтатусыЭД.Подписан);
						//МассивСтатусов.Добавить(Перечисления.СтатусыЭД.ПодготовленКОтправке);
						//МассивСтатусов.Добавить(Перечисления.СтатусыЭД.Отправлен);
					}
				}
			}
			return null;
		}
		// Формирует фамилию и инициалы по переданной строке.
		//
		// Параметры
		//  ПолноеНаименование - строка с наименованием.
		//
		// Возвращаемое значение:
		//  Строка - фамилия и инициалы одной строкой.
		//  В параметрах Фамилия, Имя и Отчество записываются вычисленные части.
		//
		// Пример:
		//  Результат = ФамилияИнициалыФизЛица("Иванов Иван Иванович"); Результат = "Иванов И. И."
		//

		public object ФамилияИнициалыФизЛица(/*ПолноеНаименование, Фамилия = " ", Имя = " ", Отчество = " "*/)
		{
			//ЭлектронныеДокументыПереопределяемый.РазобратьНаименованиеФизЛица(ПолноеНаименование, Фамилия, Имя, Отчество);
			if(true/*НЕ ЗначениеЗаполнено(Фамилия) И НЕ ЗначениеЗаполнено(Имя) И НЕ ЗначениеЗаполнено(Отчество)*/)
			{
				//ФИО = СтроковыеФункцииКлиентСервер.РазложитьСтрокуВМассивПодстрок(СокрЛП(ПолноеНаименование), " ");
				//КоличествоПодстрок = ФИО.Количество();
				//Фамилия            = ?(КоличествоПодстрок > 0, ФИО[0], "");
				//Имя                = ?(КоличествоПодстрок > 1, ФИО[1], "");
				//Отчество           = ?(КоличествоПодстрок > 2, ФИО[2], "");
			}
			return null;
		}
		// Возвращает структуру, содержащую информацию о юридическом адресе контрагента.
		//
		// Параметры:
		//  СтруктураПараметров - структура - содержит ссылки на элементы справочника;
		//  ВидКонтрагента      - строка - имя метаданных справочника;
		//  ВидАдреса           - строка - "Факт" или "Юр";
		//  ТекстОшибки         - строка - описание ошибки;
		//
		// Возвращаемое значение:
		//  СтруктураАдреса - структура - информация о юридическом адресе.
		//

		public object ПолучитьАдресСтруктурой(/*СтруктураПараметров = Неопределено,
								ВидКонтрагента = Неопределено,
								ВидАдреса = Неопределено,
								ТекстОшибки = ""*/)
		{
			//СтруктураАдреса = Новый Структура;
			//СтруктураАдреса.Вставить("АдресРФ");
			//СтруктураАдреса.Вставить("Индекс");
			//СтруктураАдреса.Вставить("КодРегион");
			//СтруктураАдреса.Вставить("Район");
			//СтруктураАдреса.Вставить("Город");
			//СтруктураАдреса.Вставить("НаселПункт");
			//СтруктураАдреса.Вставить("Улица");
			//СтруктураАдреса.Вставить("Дом");
			//СтруктураАдреса.Вставить("Корпус");
			//СтруктураАдреса.Вставить("Кварт");
			/*ЭлектронныеДокументыПереопределяемый.ПолучитьАдресСтруктурой(СтруктураАдреса, СтруктураПараметров, ВидКонтрагента,
		ВидАдреса, ТекстОшибки);*/
			return null;
		}
		// Только для внутреннего использования

		public void УдалитьЛишнийСлэшВПути(/*Путь*/)
		{
			while(true/*Найти(Путь, "\\") > 0*/)
			{
				//Путь = СтрЗаменить(Путь, "\\", "\");
			}
			//;;
		}
		// Процедура вызывается из клиентского модуля, удаляет папку,
		// созданную на сервере и переданную на клиент в качестве параметра.
		//
		// Параметры:
		// Папка - строка, путь к временной папке на сервере.
		//

		public void УдалитьПапкуНаСервере(/*Папка*/)
		{
			if(true/*ЗначениеЗаполнено(Папка)*/)
			{
				//Файл = Новый Файл(Папка);
				if(true/*Файл.Существует()*/)
				{
					//УдалитьФайлы(Папка);
				}
			}
		}
		// Только для внутреннего использования

		public object СтруктураПараметровЭД(/**/)
		{
			//ПараметрыЭД = Новый Структура;
			//ПараметрыЭД.Вставить("ВидЭД",         Неопределено);
			//ПараметрыЭД.Вставить("НаправлениеЭД", Неопределено);
			//ПараметрыЭД.Вставить("Контрагент",    Неопределено);
			//ПараметрыЭД.Вставить("Организация",   Неопределено);
			//ПараметрыЭД.Вставить("СоглашениеЭД",  Неопределено);
			//ПараметрыЭД.Вставить("Партнер",       Неопределено);
			return null;
		}
		// Возвращает текст сообщения пользователю о необходимости  настройки системы.
		//
		// Параметры:
		//  <ВидОперации> - Строка - признак выполняемой операции
		//
		// Возвращаемое значение:
		//  ТекстСообщения - <Строка> - Строка сообщения
		//

		public object ТекстСообщенияОНеобходимостиНастройкиСистемы(/*ВидОперации*/)
		{
			//ТекстСообщения = ЭлектронныеДокументыПереопределяемый.ТекстСообщенияОНеобходимостиНастройкиСистемы(ВидОперации);
			if(true/*НЕ ЗначениеЗаполнено(ТекстСообщения)*/)
			{
				if(true/*ВРег(ВидОперации) = "РАБОТАСЭД"*/)
				{
					/*ТекстСообщения = НСтр("ru = 'Для работы с электронными документами необходимо
			|в настройках системы включить использование обмена электронными документами.'");*/
				}
			}
			return null;
		}
		// Определяет настройки обмена электронными документами по структуре параметров.

		public object ОпределитьНастройкиОбменаЭД(/*СтруктураПараметров, ПараметрыСертификатов = Неопределено*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//НастройкиОбменаЭД = Неопределено;
			//НаправлениеЭД = "";
			//ВидЭД = "";
			//Контрагент = "";
			if(true/*СтруктураПараметров.Свойство("НаправлениеЭД", НаправлениеЭД) И СтруктураПараметров.Свойство("ВидЭД", ВидЭД)
		И СтруктураПараметров.Свойство("Контрагент", Контрагент)
		И ЗначениеЗаполнено(НаправлениеЭД) И ЗначениеЗаполнено(ВидЭД) И ЗначениеЗаполнено(Контрагент)*/)
			{
				//ФлагИспользованияЭЦП = Константы.ИспользоватьЭлектронныеЦифровыеПодписи.Получить();
				//Запрос  = Новый Запрос;
				//Запрос.УстановитьПараметр("НаправлениеЭД", НаправлениеЭД);
				//Запрос.УстановитьПараметр("ВидЭД",         ВидЭД);
				//Запрос.УстановитьПараметр("Контрагент",    Контрагент);
				//СоглашениеЭД = "";
				//Организация = "";
				if(true/*СтруктураПараметров.Свойство("СоглашениеЭД", СоглашениеЭД) И ЗначениеЗаполнено(СоглашениеЭД)*/)
				{
					//Запрос.УстановитьПараметр("СоглашениеЭД", СоглашениеЭД);
					//Запрос.Текст = ЭлектронныеДокументыПереопределяемый.ПолучитьТекстНастроекОбменаПоСоглашению();
				}
				if(true/*ЗначениеЗаполнено(Запрос.Текст)*/)
				{
					//РезультатЗапроса = Запрос.Выполнить();
					if(true/*НЕ РезультатЗапроса.Пустой()*/)
					{
						//ТЗ = РезультатЗапроса.Выгрузить();
						//ТекущаяНастройка = ТЗ[0];
						//НастройкиОбменаЭД = Новый Структура;
						//НастройкиОбменаЭД.Вставить("СертификатДоступен", Ложь);
						/*// Если с клиента были переданы установленные сертификаты криптографии,
*/
						/*// то надо выбрать настройку с этими сертификатами.
*/
						if(true/*ФлагИспользованияЭЦП И ПараметрыСертификатов <> Неопределено*/)
						{
							//МассивОтпечатковСертификатов = ВернутьМассивОтпечатковСтруктуры(ПараметрыСертификатов);
						}
						if(true/*ФлагИспользованияЭЦП*/)
						{
							//ФлагПодписи = НастройкиОбменаЭД.Подписывать;
						}
						//НастройкиОбменаЭД.Вставить("Подписывать", ФлагПодписи);
					}
				}
			}
			return null;
		}
		// Позволяет получить значение реквизита недоступного для чтения объекта

		public object ПолучитьЗначениеРеквизитаВПривилегированномРежиме(/*Ссылка, ИмяРеквизита*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			return null;
		}
		// Получает значение функциональной опции.
		//
		// Параметры:
		//  НаименованиеФО - Строка, имя функциональной опции
		//
		// Возвращаемое значение:
		//  ЗначениеВозврата - булево, результат включенности ФО.
		//

		public object ПолучитьЗначениеФункциональнойОпции(/*НаименованиеФО*/)
		{
			//СоответствиеФО = Новый Соответствие;
			//ЭлектронныеДокументыПереопределяемый.ПолучитьСоответствиеФункциональныхОпций(СоответствиеФО);
			//ИмяФОПрикладногоРешения = СоответствиеФО.Получить(НаименованиеФО);
			if(true/*ИмяФОПрикладногоРешения = Неопределено*/)
			{
				/*// не задано соответствие
*/
				//Результат = Ложь;
			}
			return null;
		}
		// Функция формирует прокси по настройкам прокси (передаваемому параметру)
		//
		// Параметры:
		//
		// НастройкаПроксиСервера - Соответствие:
		//		ИспользоватьПрокси - использовать ли прокси-сервер
		//		НеИспользоватьПроксиДляЛокальныхАдресов - использовать ли прокси-сервер для локальных адресов
		//		ИспользоватьСистемныеНастройки - использовать ли системные настройки прокси-сервера
		//		Сервер       - адрес прокси-сервера
		//		Порт         - порт прокси-сервера
		//		Пользователь - имя пользователя для авторизации на прокси-сервере
		//		Пароль       - пароль пользователя
		// Протокол - строка - протокол для которого устанавливаются параметры прокси сервера, например "http", "https", "ftp"
		//

		public object СформироватьПрокси(/*Протокол*/)
		{
			//НастройкаПроксиСервера = Новый Соответствие;
			//ЭлектронныеДокументыПереопределяемый.ПолучитьНастройкиПроксиСервера(НастройкаПроксиСервера);
			if(true/*НастройкаПроксиСервера.Количество() > 0*/)
			{
				//ИспользоватьПрокси = НастройкаПроксиСервера.Получить("ИспользоватьПрокси");
				//ИспользоватьСистемныеНастройки = НастройкаПроксиСервера.Получить("ИспользоватьСистемныеНастройки");
				if(true/*ИспользоватьПрокси*/)
				{
					if(true/*ИспользоватьСистемныеНастройки*/)
					{
						/*// Системные настройки прокси-сервера.
*/
						//Прокси = Новый ИнтернетПрокси(Истина);
					}
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с файлами
		// Только для внутреннего использования

		public object ТекущийКаталогВременныхФайлов(/**/)
		{
			//ТекущийКаталог = "";
			//ЭлектронныеДокументыПереопределяемый.ТекущийКаталогВременныхФайлов(ТекущийКаталог);
			if(true/*НЕ ЗначениеЗаполнено(ТекущийКаталог)*/)
			{
				//ТекущийКаталог = КаталогВременныхФайлов();
			}
			return null;
		}
		// Только для внутреннего использования

		public object ТекущееИмяВременногоФайла(/*Расширение = ""*/)
		{
			//ИмяВременногоФайла = "";
			//ЭлектронныеДокументыПереопределяемый.ТекущееИмяВременногоФайла(ИмяВременногоФайла, Расширение);
			if(true/*НЕ ЗначениеЗаполнено(ИмяВременногоФайла)*/)
			{
				//ИмяВременногоФайла = ПолучитьИмяВременногоФайла(Расширение);
			}
			return null;
		}

		public object ЕстьПравоОбработкиЭД(/*ВыводитьСообщение = Истина*/)
		{
			//ЕстьПраво = ЭлектронныеДокументыПереопределяемый.ЕстьПравоОбработкиЭД();
			if(true/*ТипЗнч(ЕстьПраво) <> Тип("Булево")*/)
			{
				//ЕстьПраво = ПользователиСервер.РолиДоступны("ВыполнениеОбменаЭД");
			}
			if(true/*НЕ ЕстьПраво И ВыводитьСообщение*/)
			{
				//СообщитьПользователюОНарушенииПравДоступа();
			}
			return null;
		}

		public object ЕстьПравоЧтенияЭД(/*ВыводитьСообщение = Истина*/)
		{
			//ЕстьПраво = ЭлектронныеДокументыПереопределяемый.ЕстьПравоЧтенияЭД();
			if(true/*ТипЗнч(ЕстьПраво) <> Тип("Булево")*/)
			{
				//ЕстьПраво = ПользователиСервер.РолиДоступны("ВыполнениеОбменаЭД, ЧтениеЭД");
			}
			if(true/*НЕ ЕстьПраво И ВыводитьСообщение*/)
			{
				//СообщитьПользователюОНарушенииПравДоступа();
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Обновление информационной базы
		// Возвращает номер версии Библиотеки стандартных подсистем.
		//

		public object ВерсияБиблиотеки(/**/)
		{
			return null;
		}
		// Неинтерактивное обновление данных ИБ при смене версии библиотеки
		// Обязательная "точка входа" обновления ИБ в библиотеке.
		//

		public void ВыполнитьОбновлениеИнформационнойБазы(/**/)
		{
			/*// Обработчик заполнения старых соглашениий новыми видами документов: ТОРГ12Продавец, ТОРГ12Покупатель,
*/
			/*// АктИсполнитель, АктЗаказчик.
*/
			//ФлагПринудительногоЗапускаОбработчика = Ложь;
			//ВерсияОбрабочтика = "1.0.4";
			/*ЭлектронныеДокументыПереопределяемый.ОпределитьФлагЗапускаОбработчикаОбновления(ВерсияОбрабочтика,
		ФлагПринудительногоЗапускаОбработчика);*/
			if(true/*ВерсияБиблиотеки() = ВерсияОбрабочтика ИЛИ ФлагПринудительногоЗапускаОбработчика*/)
			{
				//ОбновитьВидыДокументовВСоглашениях();
			}
			/*// Обработчик заполнения поля РегламентЭДО в старых соглашениях.
*/
			//ФлагПринудительногоЗапускаОбработчика = Ложь;
			//ВерсияОбрабочтика = "1.0.5";
			/*ЭлектронныеДокументыПереопределяемый.ОпределитьФлагЗапускаОбработчикаОбновления(ВерсияОбрабочтика,
		ФлагПринудительногоЗапускаОбработчика);*/
			if(true/*ВерсияБиблиотеки() = ВерсияОбрабочтика ИЛИ ФлагПринудительногоЗапускаОбработчика*/)
			{
				//ОбновитьВерсиюРегламентаЭДО();
			}
		}

		public object ПреобразоватьДатуВКаноническийВид(/*ПреобрДата*/)
		{
			if(true/*ТипЗнч(ПреобрДата) = Тип("Дата")*/)
			{
				/*КаноничДата = Формат(Год(ПреобрДата),"ЧГ=0") + Формат(Месяц(ПреобрДата), "ЧЦ=2; ЧВН=") + Формат(День(ПреобрДата), "ЧЦ=2; ЧВН=")
			+ Формат(Час(ПреобрДата), "ЧЦ=2; ЧВН=") + Формат(Минута(ПреобрДата), "ЧЦ=2; ЧВН=") + Формат(Секунда(ПреобрДата), "ЧЦ=2; ЧВН=");*/
			}
			return null;
		}

		public void ОбновитьВидыДокументовВСоглашениях(/**/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СоглашенияОбИспользованииЭД.Ссылка
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД КАК СоглашенияОбИспользованииЭД
	|ГДЕ
	|	НЕ СоглашенияОбИспользованииЭД.ПометкаУдаления
	|	И СоглашенияОбИспользованииЭД.СпособОбменаЭД = ЗНАЧЕНИЕ(Перечисление.СпособыОбменаЭД.ЧерезКаталог)";*/
			//Результат = Запрос.Выполнить().Выбрать();
			while(true/*Результат.Следующий()*/)
			{
				//ИскомоеСоглашение = Результат.Ссылка.ПолучитьОбъект();
				if(true/*ИскомоеСоглашение.ИсходящиеДокументы.Найти(Перечисления.ВидыЭД.ТОРГ12Продавец, "ИсходящийДокумент") = Неопределено*/)
				{
					//НайденаяСтрока = ИскомоеСоглашение.ИсходящиеДокументы.Найти(Перечисления.ВидыЭД.ТОРГ12, "ИсходящийДокумент");
					if(true/*НайденаяСтрока <> Неопределено*/)
					{
						//НоваяСтрока = ИскомоеСоглашение.ИсходящиеДокументы.Добавить();
						//НоваяСтрока.ИсходящийДокумент         = Перечисления.ВидыЭД.ТОРГ12Продавец;
						//НоваяСтрока.ИспользоватьЭЦП           = НайденаяСтрока.ИспользоватьЭЦП;
						//НоваяСтрока.ОжидатьКвитанциюОДоставке = НайденаяСтрока.ОжидатьКвитанциюОДоставке;
						//НоваяСтрока.Формировать               = НайденаяСтрока.Формировать;
					}
				}
				if(true/*ИскомоеСоглашение.ИсходящиеДокументы.Найти(Перечисления.ВидыЭД.ТОРГ12Покупатель, "ИсходящийДокумент") = Неопределено*/)
				{
					//НайденаяСтрока = ИскомоеСоглашение.ВходящиеДокументы.Найти(Перечисления.ВидыЭД.ТОРГ12, "ВходящийДокумент");
					if(true/*НайденаяСтрока <> Неопределено*/)
					{
						//НоваяСтрока = ИскомоеСоглашение.ИсходящиеДокументы.Добавить();
						//НоваяСтрока.ИсходящийДокумент         = Перечисления.ВидыЭД.ТОРГ12Покупатель;
						//НоваяСтрока.ИспользоватьЭЦП           = НайденаяСтрока.ИспользоватьЭЦП;
						//НоваяСтрока.ОжидатьКвитанциюОДоставке = НайденаяСтрока.ОжидатьКвитанциюОДоставке;
						//НоваяСтрока.Формировать               = НайденаяСтрока.Формировать;
					}
				}
				if(true/*ИскомоеСоглашение.ИсходящиеДокументы.Найти(Перечисления.ВидыЭД.АктИсполнитель, "ИсходящийДокумент") = Неопределено*/)
				{
					//НайденаяСтрока = ИскомоеСоглашение.ИсходящиеДокументы.Найти(Перечисления.ВидыЭД.АктВыполненныхРабот, "ИсходящийДокумент");
					if(true/*НайденаяСтрока <> Неопределено*/)
					{
						//НоваяСтрока = ИскомоеСоглашение.ИсходящиеДокументы.Добавить();
						//НоваяСтрока.ИсходящийДокумент         = Перечисления.ВидыЭД.АктИсполнитель;
						//НоваяСтрока.ИспользоватьЭЦП           = НайденаяСтрока.ИспользоватьЭЦП;
						//НоваяСтрока.ОжидатьКвитанциюОДоставке = НайденаяСтрока.ОжидатьКвитанциюОДоставке;
						//НоваяСтрока.Формировать               = НайденаяСтрока.Формировать;
					}
				}
				if(true/*ИскомоеСоглашение.ИсходящиеДокументы.Найти(Перечисления.ВидыЭД.АктЗаказчик, "ИсходящийДокумент") = Неопределено*/)
				{
					//НайденаяСтрока = ИскомоеСоглашение.ВходящиеДокументы.Найти(Перечисления.ВидыЭД.АктВыполненныхРабот, "ВходящийДокумент");
					if(true/*НайденаяСтрока <> Неопределено*/)
					{
						//НоваяСтрока = ИскомоеСоглашение.ИсходящиеДокументы.Добавить();
						//НоваяСтрока.ИсходящийДокумент         = Перечисления.ВидыЭД.АктЗаказчик;
						//НоваяСтрока.ИспользоватьЭЦП           = НайденаяСтрока.ИспользоватьЭЦП;
						//НоваяСтрока.ОжидатьКвитанциюОДоставке = НайденаяСтрока.ОжидатьКвитанциюОДоставке;
						//НоваяСтрока.Формировать               = НайденаяСтрока.Формировать;
					}
				}
				//ИскомоеСоглашение.Записать();
			}
			//;;
		}

		public void ОбновитьВерсиюРегламентаЭДО(/**/)
		{
			//НаборЗаписей = РегистрыСведений.УчастникиОбменовЭДЧерезОператоровЭДО.СоздатьНаборЗаписей();
			//НаборЗаписей.Прочитать();
			//НаборЗаписей.Записать();
		}
		////////////////////////////////////////////////////////////////////////////////
		// СЛУЖЕБНЫЕ ПРОЦЕДУРЫ И ФУНКЦИИ
		////////////////////////////////////////////////////////////////////////////////
		// Получение данных объектов для сравнения

		public void ДобавитьИтераторТаблице(/*Таблица, ЗначениеИтератора*/)
		{
			//Таблица.Колонки.Добавить("ИтераторТаблицыРеквизитовОбъекта");
			//Таблица.ЗаполнитьЗначения(ЗначениеИтератора, "ИтераторТаблицыРеквизитовОбъекта");
		}

		public object ИнициализацияТаблицыРеквизитовОбъектов(/**/)
		{
			//ТаблицаРеквизитов = Новый ТаблицаЗначений;
			//Колонки = ТаблицаРеквизитов.Колонки;
			//Колонки.Добавить("Порядок",                    Новый ОписаниеТипов("Число"));
			//Колонки.Добавить("ИмяОбъекта",                 Новый ОписаниеТипов("Строка"));
			//Колонки.Добавить("ИмяТабличнойЧасти",          Новый ОписаниеТипов("Строка"));
			//Колонки.Добавить("РеквизитыОбъекта",           Новый ОписаниеТипов("Строка"));
			//Колонки.Добавить("СтруктураРеквизитовОбъекта", Новый ОписаниеТипов("Структура"));
			//ТаблицаРеквизитов.Индексы.Добавить("ИмяОбъекта");
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Управление электронной почтой

		public object СформироватьТемуПисьма(/*Отправитель, Получатель*/)
		{
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Регламентные задания

		public void СформироватьЭДПрисоединенныйФайлПакета(/*Конверт*/)
		{
			//ПодготовленныеДокументы = ПолучитьЭлектронныеДокументыКонвертов(Конверт);
			//ЭтоПроизвольныйДокумент = ЭтоПакетПроизвольногоЭД(ПодготовленныеДокументы);
			//УникальныйИдентификатор = Новый УникальныйИдентификатор;
			//СоответствиеФайлЭД      = Новый Соответствие;
			//АдресКаталога = РабочийКаталог("Отправка", Конверт.Ссылка.УникальныйИдентификатор());
			//УдалитьФайлы(АдресКаталога, "*");
			//Файлы = НайтиФайлы(АдресКаталога, "*");
			//Файлы = НайтиФайлы(АдресКаталога, "*");
			if(true/*Файлы.Количество() = 0*/)
			{
			}
			//МассивИменФайлов = Новый Массив;
			//ЗипКонтейнер = Новый ЗаписьZipФайла();
			//ИмяФайла = "EDI_" + Конверт.УникальныйИдентификатор();
			//ОбщегоНазначенияКлиентСервер.ЗаменитьНедопустимыеСимволыВИмениФайла(ИмяФайла);
			//ЗипКонтейнер.Открыть(АдресКаталога+ИмяФайла+".zip");
			//СоответствиеВложений 	= ПолучитьСоответствиеФайловИПодписей(МассивИменФайлов);
			/*ТекстОписанияУчастников = СоздатьТекстОписиЭД(Конверт.Отправитель, Конверт.Получатель, Конверт, СоответствиеВложений,
		СоответствиеФайлЭД, ЭтоПроизвольныйДокумент);*/
			//КопироватьФайл(ТекстОписанияУчастников, АдресКаталога+"packageDescription.xml");
			//ЗипКонтейнер.Добавить(АдресКаталога+"packageDescription.xml");
			//ЗипКонтейнер.Записать();
			//ПоместитьПакетЭДВКонверт(Конверт, АдресКаталога + ИмяФайла+".zip");
			//УдалитьФайлы(АдресКаталога);
		}

		public object РаспаковатьПакетЭДНаСервере(/*ПакетЭД, ПараметрыШифрования = ""*/)
		{
			//МассивВозврата = Новый Массив;
			//ПапкаДляРаспаковки = РабочийКаталог("Распаковка",  ПакетЭД.Ссылка.УникальныйИдентификатор());
			//ПапкаДляРасшифровки = РабочийКаталог("Расшифровка", ПакетЭД.Ссылка.УникальныйИдентификатор());
			//ДанныеРаспаковки  = ВернутьМассивДвоичныхДанныхПакета(ПакетЭД, ПапкаДляРаспаковки, ПараметрыШифрования);
			/*// Если это был произвольный ЭД.
*/
			if(true/*ДанныеРаспаковки = Неопределено*/)
			{
			}
			//МассивДвоичныхДанных = ДанныеРаспаковки.СтруктураДвоичныхДанных;
			//МассивДвоичныхДанныхИзвещений = ДанныеРаспаковки.СтруктураДвоичныхДанныхИзвещений;
			if(true/*МассивДвоичныхДанных.Количество() = 0*/)
			{
				//ОбработатьПодтвержденияДокументовНаСервере(ДанныеРаспаковки.СоответствиеФайлПараметры, ПакетЭД, ПапкаДляРаспаковки);
			}
			if(true/*МассивДвоичныхДанныхИзвещений.Количество() > 0*/)
			{
			}
			//ЕстьОшибкаРаспаковки=Ложь;
			if(true/*ЕстьОшибкаРаспаковки*/)
			{
			}
			//УстановитьСтатусПакета(ПакетЭД, Перечисления.СтатусыПакетовЭД.Распакован);
			//УдалитьФайлы(ПапкаДляРаспаковки);
			return null;
		}

		public object ОпределитьПодготовленныеКОтправкеЭД(/**/)
		{
			//ЗапросПодготовленныхЭД = Новый Запрос;
			/*ЗапросПодготовленныхЭД.Текст =
	"ВЫБРАТЬ РАЗРЕШЕННЫЕ
	|	ПакетЭД.Ссылка КАК Ссылка
	|ИЗ
	|	Документ.ПакетЭД КАК ПакетЭД
	|ГДЕ
	|	ПакетЭД.ПометкаУдаления = ЛОЖЬ
	|	И ПакетЭД.СтатусПакета = &СтатусПакета";*/
			//ЗапросПодготовленныхЭД.УстановитьПараметр("СтатусПакета", Перечисления.СтатусыПакетовЭД.ПодготовленКОтправке);
			//Результат = ЗапросПодготовленныхЭД.Выполнить().Выгрузить().ВыгрузитьКолонку("Ссылка");
			return null;
		}

		public object ОтправитьЭлектронноеПисьмо(/*ПодготовленныеДокументы, АдресКаталогаСВложениями*/)
		{
			//СоответствиеВложений = СформироватьСоответствиеВложений(АдресКаталогаСВложениями);
			//Результат = ПередатьПисьмоСВложениями(ПодготовленныеДокументы, СоответствиеВложений);
			//УдалитьФайлы(АдресКаталогаСВложениями);
			return null;
		}

		public object ЭтоПакетПроизвольногоЭД(/*МассивДокументов*/)
		{
			return null;
		}

		public object СформироватьФайлыДляОтправки(/*Конверт*/)
		{
			//ФайлыЭД = ПолучитьВыборкуЭДПоОтбору(Новый Структура("ВладелецФайла", Конверт));
			//УникальныйИдентификатор = Новый УникальныйИдентификатор;
			//АдресКаталога = РабочийКаталог("Отправка", Конверт.Ссылка.УникальныйИдентификатор());
			while(true/*ЗначениеЗаполнено(ФайлыЭД) И ФайлыЭД.Следующий()*/)
			{
				//ДанныеФайла = ПрисоединенныеФайлы.ПолучитьДанныеФайла(ФайлыЭД.Ссылка);
				//ДвоичныеДанные = ПолучитьИзВременногоХранилища(ДанныеФайла.СсылкаНаДвоичныеДанныеФайла);
				//ДвоичныеДанные.Записать(АдресКаталога + ДанныеФайла.ИмяФайла);
			}
			return null;
		}

		public object СформироватьСписокРасширенийСертификатов(/**/)
		{
			//СписокРасширений = Новый СписокЗначений;
			//СписокРасширений.Добавить(".p7s");
			return null;
		}

		public object СформироватьСоответствиеВложений(/*КаталогВложений, ТолькоПодписи = Ложь*/)
		{
			//СписокДоступныхРасширений = СформироватьСписокРасширенийСертификатов();
			//СоответствиеВозврата = Новый Соответствие;
			//СписокВложений = НайтиФайлы(КаталогВложений, "*");
			return null;
		}

		public object НайтиИменаФайловПодписей(/*ИмяФайлаДанных, ИменаФайловПодписей*/)
		{
			//ИменаПодписей = Новый Массив;
			//Файл = Новый Файл(ИмяФайлаДанных);
			//ИмяБезРасширения = Файл.ИмяБезРасширения;
			return null;
		}

		public object ОтправкаСформированныхЭД(/*СоответствиеПаролейДляЭДО = Неопределено*/)
		{
			//Результат = 0;
			/*// Создадим и заполним документы ПакетыЭД
*/
			//ГотовыеКОтправкеПакеты = ОпределитьПодготовленныеКОтправкеЭД();
			if(true/*ЗначениеЗаполнено(ГотовыеКОтправкеПакеты)*/)
			{
				//Результат = ОтправкаПакетовЭД(ГотовыеКОтправкеПакеты, СоответствиеПаролейДляЭДО);
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с сертификатами ЭЦП
		// Проверяет действительность подписи, без учета списка отозванных сертификатов.
		// В случае ошибки генерирует исключение
		//
		// Параметры
		//  МенеджерКриптографии  - МенеджерКриптографии - менеджер криптографии
		//  ДвоичныеДанныеФайла   - двоичные данные файла
		//  ДвоичныеДанныеПодписи - двоичные данные подписи
		//

		public void ПроверитьПодпись(/*МенеджерКриптографии, ДвоичныеДанныеФайла, ДвоичныеДанныеПодписи*/)
		{
			//Сертификат = Неопределено;
			//МенеджерКриптографии.ПроверитьПодпись(ДвоичныеДанныеФайла, ДвоичныеДанныеПодписи, Сертификат);
		}

		public void СохранитьПодписи(/*ФайлСсылка,
							ПолноеИмяФайла,
							УникальныйИдентификатор,
							МассивСтруктурПодписей,
							АдресКаталога,
							СоответствиеФайлЭД,
							БезИсходника = Ложь,
							ЭтоПроизвольныйЭД = Ложь*/)
		{
			//ОсновнойФайл = Новый Файл(ПолноеИмяФайла);
			//Путь = ОсновнойФайл.Путь;
			//МассивИмен = Новый Массив;
			//ТипПлатформыСервера = ОбщегоНазначенияПовтИсп.ТипПлатформыСервера();
			if(true/*НЕ БезИсходника*/)
			{
				//МассивИмен.Добавить(ОсновнойФайл.Имя);
			}
			//Сч = 0;
		}
		// Возвращает пароль к переданному сертификату,
		// если он был сохранен в базе
		//
		// Параметры
		//  Сертификат  - элемент справочника СертификатыЭЦП

		public object СохраненныйПарольКСертификату(/*Сертификат*/)
		{
			//ПарольКСертификату = Неопределено;
			if(true/*ЗначениеЗаполнено(Сертификат) И Сертификат.ЗапомнитьПарольКСертификату*/)
			{
				//ПарольКСертификату = Сертификат.ПарольПользователя;
			}
			return null;
		}

		public object ПолучитьСоответствиеФайловИПодписей(/*ИменаФайлов*/)
		{
			//Результат = Новый Соответствие;
			//ИменаФайловПодписей = Новый Массив;
			//ИменаФайловДанных   = Новый Массив;
			return null;
		}

		public object СохранитьФайлКак(/*ДанныеФайла,
						ИмяКаталога,
						ПрисоединенныйФайл = Неопределено,
						СсылкаНаПакет = Неопределено,
						ЭтоПроизвольныйЭД = Неопределено,
						СоответствиеФайлЭД= Неопределено*/)
		{
			//Файл = Новый Файл(ИмяКаталога);
			if(true/*НЕ Файл.Существует()*/)
			{
				//СоздатьКаталог(ИмяКаталога);
			}
			//РазмерВМб = ДанныеФайла.Размер / (1024 * 1024);
			//ИмяПолучаемогоФайла = СтрЗаменить(ДанныеФайла.ИмяФайла, "..", ".");
			//ДвоичныеДанныеФайла = ПолучитьИзВременногоХранилища(ДанныеФайла.СсылкаНаДвоичныеДанныеФайла);
			//ДвоичныеДанныеФайла.Записать(ИмяКаталога + ИмяПолучаемогоФайла);
			if(true/*ЗначениеЗаполнено(ПрисоединенныйФайл)*/)
			{
				if(true/*ТипЗнч(СоответствиеФайлЭД) = Тип("Соответствие")*/)
				{
					//СоответствиеФайлЭД.Вставить(ДанныеФайла.ИмяФайла, ПрисоединенныйФайл.НомерЭД);
				}
				//ПутьКФайлу = Файл.Путь;
				if(true/*Прав(ПутьКФайлу,1) <> "\"*/)
				{
					//ПутьКФайлу = ПутьКФайлу + "\";
				}
			}
			if(true/*ЗначениеЗаполнено(ЭтоПроизвольныйЭД) И ЭтоПроизвольныйЭД*/)
			{
				//ИмяФайла      = ДанныеФайла.Наименование;
				//ИмяКонтейнера = ИмяКаталога + ИмяФайла + ".zip";
				//ИмяАрхива     = ИмяФайла + ".zip";
				if(true/*ИмяФайла + ".zip" = ИмяПолучаемогоФайла*/)
				{
					//ИмяКонтейнера = ИмяКаталога+ИмяФайла+"ЭЦП.zip";
					//ИмяАрхива     = ИмяФайла + "ЭЦП.zip";
				}
				//ЗипКонтейнер = Новый ЗаписьZipФайла(ИмяКонтейнера);
				//ЗипКонтейнер.Добавить(ИмяКаталога + ИмяПолучаемогоФайла );
				//ЗипКонтейнер.Записать();
				if(true/*ИмяФайла + ".zip" = ИмяПолучаемогоФайла*/)
				{
					//УдалитьФайлы(ИмяКаталога + ИмяПолучаемогоФайла);
				}
				if(true/*ЗначениеЗаполнено(ПрисоединенныйФайл)*/)
				{
					//СоответствиеФайлЭД.Вставить(ИмяАрхива, ПрисоединенныйФайл.НомерЭД);
				}
			}
			//ПараметрыШифрования = ПолучитьМассивАдресовСертификатовШифрования(ПрисоединенныйФайл);
			if(true/*ПараметрыШифрования <> Неопределено*/)
			{
				//ДвоичныеДанныеСертификата = ПолучитьИзВременногоХранилища(ПараметрыШифрования[0]);
				//ДвоичныеДанныеСертификатаОрганизации = ПолучитьИзВременногоХранилища(ПараметрыШифрования[1]);
				//Сертификат = Новый СертификатКриптографии(ДвоичныеДанныеСертификата);
				//СертификатОрганизации = Новый СертификатКриптографии(ДвоичныеДанныеСертификатаОрганизации);
				//МассивСертификатов = Новый Массив;
				//МассивСертификатов.Добавить(Сертификат);
				//МассивСертификатов.Добавить(СертификатОрганизации);
				//ДвоичныеДанныеФайла = Новый ДвоичныеДанные(ИмяКаталога + ИмяПолучаемогоФайла);
				//МенеджерКриптографии.Зашифровать(ДвоичныеДанныеФайла, ИмяКаталога + ИмяПолучаемогоФайла, МассивСертификатов);
				//ДобавитьПризнакШифрованияПакетуЭД(СсылкаНаПакет, ПрисоединенныйФайл, ПараметрыШифрования);
			}
			return null;
		}
		// Получение актуальных сертификатов для подписи электронных документов

		public object ДоступныДляПодписиСертификаты(/*МассивСтруктурСертификатов*/)
		{
			//МассивОтпечатков = Новый Массив;
			//ЗапросПоСертификатам = Новый Запрос;
			/*ЗапросПоСертификатам.Текст =
	"ВЫБРАТЬ РАЗЛИЧНЫЕ РАЗРЕШЕННЫЕ
	|	СертификатыЭЦП.Ссылка,
	|	СертификатыЭЦП.Отпечаток
	|ИЗ
	|	Справочник.СертификатыЭЦП КАК СертификатыЭЦП
	|ГДЕ
	|	СертификатыЭЦП.Отозван = ЛОЖЬ
	|	И (СертификатыЭЦП.Пользователь = &ТекущийПользователь
	|			ИЛИ СертификатыЭЦП.Пользователь = ЗНАЧЕНИЕ(Справочник.Пользователи.ПустаяСсылка))
	|	И СертификатыЭЦП.ПометкаУдаления = ЛОЖЬ
	|	И СертификатыЭЦП.Отпечаток В(&МассивОтпечатков)";*/
			//ЗапросПоСертификатам.УстановитьПараметр("ТекущийПользователь", ПользователиСервер.ТекущийПользователь());
			//ЗапросПоСертификатам.УстановитьПараметр("МассивОтпечатков",    МассивОтпечатков);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с версиями ЭД

		public object ПолучитьПоследнююВерсиюЭДПоВладельцу(/*СсылкаНаВладельца*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ЗапросЭД = Новый Запрос;
			//ЗапросЭД.УстановитьПараметр("СсылкаНаВладельца", СсылкаНаВладельца);
			/*ЗапросЭД.Текст =
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	ЭДПрисоединенныеФайлы.НомерВерсииЭД КАК НомерВерсии
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.ПометкаУдаления = ЛОЖЬ
	|	И ЭДПрисоединенныеФайлы.ВладелецФайла = &СсылкаНаВладельца
	|
	|УПОРЯДОЧИТЬ ПО
	|	ЭДПрисоединенныеФайлы.НомерВерсииЭД УБЫВ";*/
			//Результат = ЗапросЭД.Выполнить().Выбрать();
			if(true/*Результат.Следующий()*/)
			{
			}
			return null;
		}

		public object СостояниеВерсииЭД(/*СсылкаНаВладельца*/)
		{
			//ВозвращаемоеЗначение = Перечисления.СостоянияВерсийЭД.ПустаяСсылка();
			//СтруктураВерсииЭД = ПолучитьСтруктуруВерсииЭД(СсылкаНаВладельца);
			if(true/*СтруктураВерсииЭД.Свойство("СостояниеВерсииЭД")*/)
			{
				//ВозвращаемоеЗначение = СтруктураВерсииЭД.СостояниеВерсииЭД;
			}
			return null;
		}

		public void УдалитьСтаруюВерсиюЭД(/*ЗаписьНабора*/)
		{
			//СтруктураВерсии = ПолучитьСтруктуруВерсииЭД(ЗаписьНабора.СсылкаНаОбъект);
			if(true/*ЗначениеЗаполнено(СтруктураВерсии.СсылкаНаДокумент)
		И (СтруктураВерсии.СтатусЭД = Перечисления.СтатусыЭД.Сформирован
		ИЛИ СтруктураВерсии.СтатусЭД = Перечисления.СтатусыЭД.Утвержден)*/)
			{
				//ДокументОбъект = СтруктураВерсии.СсылкаНаДокумент.ПолучитьОбъект();
				//ДокументОбъект.ПометкаУдаления = Истина;
				//ДокументОбъект.Записать();
			}
		}

		public object ПолучитьПервоеСостояниеВерсииЭДДляВладельца(/*СсылкаНаВладельца, ПризнакПолучения = Ложь*/)
		{
			//ПараметрыЭД = ЭлектронныеДокументыВызовСервераСлужебный.ЗаполнитьПараметрыЭДПоИсточнику(СсылкаНаВладельца.Ссылка);
			//СостояниеВерсииЭД = Перечисления.СостоянияВерсийЭД.ПустаяСсылка();
			//НаправлениеЭД = "";
			if(true/*ПараметрыЭД.Свойство("НаправлениеЭД", НаправлениеЭД) И ЗначениеЗаполнено(НаправлениеЭД)*/)
			{
				if(true/*НаправлениеЭД = Перечисления.НаправленияЭД.Исходящий 
			ИЛИ НаправлениеЭД = Перечисления.НаправленияЭД.Интеркампани*/)
				{
					//СостояниеВерсииЭД = Перечисления.СостоянияВерсийЭД.НеСформирован;
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Добавление объектов в присоединенные файлы

		public void СформироватьХМЛФайл(/*ТекЭлемент, МассивСтруктурВозврата, ПараметрыОбмена, ДопПараметры*/)
		{
			//МассивОбъектовДляВыгрузки = ТекЭлемент.Значение;
			//ЭлектронныеДокументыПереопределяемый.ПроверитьГотовностьИсточников(МассивОбъектовДляВыгрузки);
		}

		public void УстановитьСсылкуДляВладельцаВРегистреСостояний(/*СсылкаНаОбъект, ЭлектронныйДокумент*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*НЕ ЭтоСлужебныйДокумент(ЭлектронныйДокумент)*/)
			{
				//НаборЗаписей = РегистрыСведений.СостоянияЭД.СоздатьНаборЗаписей();
				//НаборЗаписей.Отбор.СсылкаНаОбъект.Установить(СсылкаНаОбъект);
				//НаборЗаписей.Прочитать();
				if(true/*НаборЗаписей.Количество()=0*/)
				{
					//НоваяЗаписьНабора = НаборЗаписей.Добавить();
					//НоваяЗаписьНабора.СсылкаНаОбъект = СсылкаНаОбъект;
				}
				//НоваяЗаписьНабора.ЭлектронныйДокумент = ЭлектронныйДокумент;
				//НаборЗаписей.Записать();
			}
		}

		public object СформироватьДопДокумент(/*СтруктураОбмена, ОписаниеФормата*/)
		{
			/*ТабличныйДокумент = ЭлектронныеДокументыФорматОбмена.СформироватьПечатнуюФормуЭД(
		СтруктураОбмена.ПолноеИмяФайла, СтруктураОбмена.СтруктураЭД.НаправлениеЭД);*/
			//СтруктураОбработкиДопФайла = ОпределитьТипСохраненияПоПеречислению(ОписаниеФормата);
			//ФайлИсходногоДокумента = Новый Файл(СтруктураОбмена.ПолноеИмяФайла);
			//ИмяИсходногоДокумента = ФайлИсходногоДокумента.ИмяБезРасширения;
			/*ФайлСохранения = ФайлИсходногоДокумента.Путь + ИмяИсходногоДокумента +"."
		+ СтруктураОбработкиДопФайла.ПредставлениеРасширения;*/
			//ТабличныйДокумент.Записать(ФайлСохранения,СтруктураОбработкиДопФайла.ПредставлениеТипаСохранения);
			return null;
		}

		public object ОпределитьТипСохраненияПоПеречислению(/*ТипСохранения*/)
		{
			//СтруктураВозврата = Новый Структура("ПредставлениеРасширения, ПредставлениеТипаСохранения");
			if(true/*ТипСохранения = Перечисления.ФорматыФайловОбменаЭД.DOCX*/)
			{
				//СтруктураВозврата.ПредставлениеРасширения = "docx";
				//СтруктураВозврата.ПредставлениеТипаСохранения = ТипФайлаТабличногоДокумента.DOCX;
			}
			return null;
		}

		public object СформироватьЗипАрхивФайлов(/*ИмяОсновногоФайла, МассивФайлов*/)
		{
			return null;
		}

		public object ПолучитьПолноеИмяФайлаЭД(/*СтруктураОбмена*/)
		{
			/*// Формируем ЭД в формате xml, в случае если это:
*/
			/*// - торг-12 в формате ФНС;
*/
			/*// - Акт в формате ФНС;
*/
			/*// - торг-12 в старом формате;
*/
			/*// - обмен через оператора ЭДО счетом-фактурой.
*/
			if(true/*(СтруктураОбмена.ВидЭД = Перечисления.ВидыЭД.ТОРГ12Продавец
		ИЛИ СтруктураОбмена.ВидЭД = Перечисления.ВидыЭД.ТОРГ12Покупатель
		ИЛИ СтруктураОбмена.ВидЭД = Перечисления.ВидыЭД.АктИсполнитель
		ИЛИ СтруктураОбмена.ВидЭД = Перечисления.ВидыЭД.АктЗаказчик)
		ИЛИ СтруктураОбмена.СтруктураЭД.СоглашениеЭД.СпособОбменаЭД = Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском
		И (СтруктураОбмена.ВидЭД = Перечисления.ВидыЭД.СчетФактура ИЛИ СтруктураОбмена.ВидЭД = Перечисления.ВидыЭД.ТОРГ12)*/)
			{
				//ПолноеИмяФайла = СтруктураОбмена.ПолноеИмяФайла;
			}
			return null;
		}
		// Функция формирует электронные документы и помещает их в справочник присоединенных файлов
		//
		// Параметры:
		//  МассивОбъектов - массив ссылок на объекты, к которым надо создать электронный документ;
		//  СоответствиеПараметров - соответствие, содержащая настройки обмена ЭД для объектов.
		//

		public object СформироватьПрисоединенныеФайлы(/*МассивОбъектов, ПараметрыОбмена, ДопПараметры = ""*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//МассивСтруктурОбмена = СформироватьХМЛФайлыДокументов(МассивОбъектов, ПараметрыОбмена, ДопПараметры);
			//МассивСформированныхФайлов = Новый Массив;
			return null;
		}

		public object ПолучитьСтруктуруФайла(/*Строка*/)
		{
			//ИмяФайла = КорректноеИмяФайла(Строка, Истина);
			//Файл = Новый Файл(ИмяФайла);
			return null;
		}

		public object СформироватьХМЛФайлыДокументов(/*МассивОбъектовДляВыгрузки, ПараметрыОбмена, ДопПараметры = ""*/)
		{
			//МассивСтруктурВозврата = Новый Массив;
			//СтруктураВидовЭД = Новый Соответствие;
			return null;
		}

		public object СоздатьПрисоединенныйДопФайл(/*СтруктураПараметров, ЭДВладелец*/)
		{
			//ДопЭДСоздан = Ложь;
			//ПолноеИмяФайла = СтруктураПараметров.ПолноеИмяДопФайла;
			if(true/*ЗначениеЗаполнено(ПолноеИмяФайла)*/)
			{
				//ВремяСозданияЭД = СтруктураПараметров.СтруктураЭД.ДатаЭД;
				//ВладелецЭД = СтруктураПараметров.СтруктураЭД.ВладелецЭД;
				//Файл = Новый Файл(ПолноеИмяФайла);
				//ДвоичныеДанные = Новый ДвоичныеДанные(Файл.ПолноеИмя);
				//АдресФайла = ПоместитьВоВременноеХранилище(ДвоичныеДанные);
				//УникальныйИдентификаторЭД = "";
				//СтруктураПараметров.Свойство("ИдентификаторДопФайла", УникальныйИдентификаторЭД);
				/*ДобавленныйФайл = ПрисоединенныеФайлы.ДобавитьФайл(ВладелецЭД, Файл.ИмяБезРасширения , СтрЗаменить(Файл.Расширение, ".", ""),
			ВремяСозданияЭД, ВремяСозданияЭД, АдресФайла, Неопределено, , "ЭДПрисоединенныеФайлы", УникальныйИдентификаторЭД);*/
				//УдалитьФайлы(ПолноеИмяФайла);
				if(true/*ЗначениеЗаполнено(ДобавленныйФайл)*/)
				{
					//ДопЭДСоздан = Истина;
					//ВспомСтруктура = Новый Структура;
					//ВспомСтруктура.Вставить("ВидЭД", Перечисления.ВидыЭД.ДопДанные);
					//ВспомСтруктура.Вставить("Контрагент", СтруктураПараметров.СтруктураЭД.Контрагент);
					//ВспомСтруктура.Вставить("ВладелецЭД", ВладелецЭД);
					//ВспомСтруктура.Вставить("СоглашениеЭД", СтруктураПараметров.СтруктураЭД.СоглашениеЭД);
					//ВспомСтруктура.Вставить("УникальныйИД", Строка(ДобавленныйФайл.УникальныйИдентификатор()));
					//ВспомСтруктура.Вставить("НаправлениеЭД", Перечисления.НаправленияЭД.Исходящий);
					//ВспомСтруктура.Вставить("ТипЭлементаВерсииЭД", Перечисления.ТипыЭлементовВерсииЭД.ДополнительныйЭД);
					//ВспомСтруктура.Вставить("ЭлектронныйДокументВладелец", ЭДВладелец);
					//ДатаФормированияЭДОтправителем = "";
					if(true/*НЕ СтруктураПараметров.СтруктураЭД.Свойство("ДатаФормированияЭДОтправителем", ДатаФормированияЭДОтправителем)*/)
					{
						//ДатаФормированияЭДОтправителем = ВремяСозданияЭД;
					}
					//СтруктураПараметров.СтруктураЭД.Вставить("ДатаФормированияЭДОтправителем", ДатаФормированияЭДОтправителем);
					//ЭлектронныеДокументы.ИзменитьПоСсылкеПрисоединенныйФайл(ДобавленныйФайл, ВспомСтруктура);
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Отправка сообщений с ЭЦП
		// Отправляет письмо с вложениями по пакету ЭД.
		//
		// Параметры:
		//  Конверт - Ссылка на документ "ПакетЭД" - подготовленный к отправке пакет электронных документов,
		//  СоответствиеВложений - Соответствие, список вложенных файлов в пакет электронных документов.
		//

		public object ПередатьПисьмоСВложениями(/*ПакетЭД, СоответствиеВложений*/)
		{
			//Получатель = ПакетЭД.Получатель;
			//Отправитель = ПакетЭД.Отправитель;
			/*ПараметрыОтправки = Новый Структура("Кому, Тема, Тело, Вложения, Пароль",
		ПакетЭД.АдресРесурсаКонтрагента, СформироватьТемуПисьма(Отправитель, Получатель), , СоответствиеВложений,
		ПакетЭД.АдресРесурсаОрганизации.Пароль);*/
			//РаботаСПочтовымиСообщениями.ОтправитьСообщение(ПакетЭД.АдресРесурсаОрганизации, ПараметрыОтправки);
			return null;
		}

		public object СоздатьТекстОписиЭД(/*ЦентрОбменаЭД, УчастникОбменаЭД, Конверт, СоответствиеВложений, СоответствиеФайлЭД, ЭтоПроизвольныйДокумент*/)
		{
			//ИмяФайла = ТекущееИмяВременногоФайла("xml");
			//ЗаписьХМЛ = Новый ЗаписьXML;
			//ЗаписьХМЛ.ОткрытьФайл(ИмяФайла);
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ТранспортнаяИнформация");
			/*// Имя документа
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ДатаИВремяФормирования");
			//ЗаписьХМЛ.ЗаписатьТекст(Строка(ТекущаяДатаСеанса()));
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			/*// Идентификатор документа
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("Идентификатор");
			//ЗаписьХМЛ.ЗаписатьТекст(Строка(Конверт.УникальныйИдентификатор()));
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			/*// Дата получения
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("Отправитель");
			//ЗаписьХМЛ.ЗаписатьТекст(ЦентрОбменаЭД);
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("Получатель");
			//ЗаписьХМЛ.ЗаписатьТекст(УчастникОбменаЭД);
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			/*// Текст произвольного документа
*/
			if(true/*ЭтоПроизвольныйДокумент*/)
			{
				//Текст = Конверт.ЭлектронныеДокументы[0].ЭлектронныйДокумент.ВладелецФайла.Текст;
				//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("Текст");
				//ЗаписьХМЛ.ЗаписатьТекст(Текст);
				//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			}
			/*// Шифрование по документам
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("НастройкиШифрования");
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ДокументыИПодписи");
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.Закрыть();
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Получение почты

		public void ОбработатьПодтверждениеПолучения(/*Сообщение, ЭтоФайл = Ложь*/)
		{
			if(true/*ЭтоФайл*/)
			{
				//ЧтениеХМЛ = Новый ЧтениеXML;
				//ЧтениеХМЛ.ОткрытьФайл(Сообщение.ПолноеИмя);
				while(true/*ЧтениеХМЛ.Прочитать()*/)
				{
					if(true/*ЧтениеХМЛ.ЛокальноеИмя = "ЭлектронныйДокумент" И ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//ДокументПакетЭД = ОпределитьПодтверждаемыйПакетЭД(ЧтениеХМЛ.Значение);
					}
					if(true/*ЧтениеХМЛ.ЛокальноеИмя = "ДатаПолучения" И ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//ДатаПолучения = Дата(ЧтениеХМЛ.Значение);
					}
				}
				/*;
		ЧтениеХМЛ.Закрыть();*/
				if(true/*ЗначениеЗаполнено(ДокументПакетЭД) И ДокументПакетЭД.СтатусПакета <> Перечисления.СтатусыПакетовЭД.Доставлен
			И ДатаПолучения <> Дата('00010101')*/)
				{
					//ОбновитьСтатусыДокументовПакетаЭД(ДокументПакетЭД, Перечисления.СтатусыПакетовЭД.Доставлен, ДатаПолучения);
				}
				//УдалитьФайлы(Сообщение.ПолноеИмя);
			}
		}

		public void ОтправитьПодтверждениеПоПакету(/*ПакетЭД, РесурсОтправителя, АдресОтправителя, ТипОтправки*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ВыборкаПрисоединенныхФайлов = ПолучитьВыборкуЭДПоОтбору(Новый Структура("ВладелецФайла",ПакетЭД));
			if(true/*ЗначениеЗаполнено(ВыборкаПрисоединенныхФайлов) И ВыборкаПрисоединенныхФайлов.Следующий()*/)
			{
				if(true/*ТипОтправки = Перечисления.СпособыОбменаЭД.ЧерезЭлектроннуюПочту*/)
				{
					if(true/*ПакетЭД.Соглашение.СпособОбменаЭД = Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском*/)
					{
					}
				}
			}
		}

		public void ОбновитьСтатусыДокументовПакетаЭД(/*ПакетЭД, НовыйСтатусПакетаЭД, ДатаИзменения*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*НЕ ЗначениеЗаполнено(ПакетЭД)*/)
			{
			}
		}

		public void ОбработатьФайлПодтвержденияОператора(/*ИмяФайла*/)
		{
			//ЧтениеХМЛ = Новый ЧтениеXML;
			//ЧтениеХМЛ.ОткрытьФайл(ИмяФайла);
			//ИдентификаторЭлектронногоДокумента = "";
			while(true/*ЧтениеХМЛ.Прочитать()*/)
			{
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Документ"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//ИдентификаторЭлектронногоДокумента = ЧтениеХМЛ.Значение;
				}
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "ИДПодтверждения"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//ИдентификаторПодтверждения = ЧтениеХМЛ.Значение;
				}
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Направление"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//НаправлениеДокумента = Перечисления.НаправленияЭД[ЧтениеХМЛ.Значение];
				}
			}
			/*;
	
	ЧтениеХМЛ.Закрыть();*/
			if(true/*Не ПустаяСтрока(ИдентификаторЭлектронногоДокумента)*/)
			{
				/*СтруктураВладельцев = ДобавитьПодтверждениеКЭлектроннымДокументамРодителя(
			ИмяФайла, ИдентификаторЭлектронногоДокумента, НаправлениеДокумента);*/
				//СформироватьИзвещениеПоПодтверждению(ИдентификаторПодтверждения, СтруктураВладельцев);
			}
		}

		public void СформироватьИзвещениеПоПодтверждению(/*ИдентификаторПодтверждения, СтруктураВладельцев*/)
		{
			if(true/*НЕ ЗначениеЗаполнено(СтруктураВладельцев) ИЛИ  СтруктураВладельцев.Владелец = Неопределено*/)
			{
			}
			//КлючУникальности = Новый УникальныйИдентификатор;
			//АдресКаталога = РабочийКаталог( ,КлючУникальности);
			//ИмяФайлаИзвещения = АдресКаталога + "Извещение.xml";
			//ЗаписьХМЛ = Новый ЗаписьXML;
			//ЗаписьХМЛ.ОткрытьФайл(ИмяФайлаИзвещения);
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ТранспортнаяИнформация");
			/*// Идентификатор подтверждения
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ИДПодтверждения");
			//ЗаписьХМЛ.ЗаписатьТекст(ИдентификаторПодтверждения);
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ДатаИВремяФормирования");
			//ЗаписьХМЛ.ЗаписатьТекст(Строка(ТекущаяДатаСеанса()));
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.Закрыть();
			//АдресВоВременномХранилище = ПоместитьВоВременноеХранилище(Новый ДвоичныеДанные(ИмяФайлаИзвещения));
			//УдалитьФайлы(АдресКаталога);
			/*ДобавленныйФайл = ПрисоединенныеФайлы.ДобавитьФайл(СтруктураВладельцев.Владелец, "ИзвещениеОператору", "xml",
		ТекущаяДатаСеанса(), ТекущаяДатаСеанса(), АдресВоВременномХранилище, Неопределено, , "ЭДПрисоединенныеФайлы");*/
			//НовыйСтатусЭД = ПолучитьДопустимыйСтатусЭД(Перечисления.СтатусыЭД.Сформирован, ДобавленныйФайл);
			/*СтруктураИзвещения = Новый Структура("ВидЭД, Контрагент, ВладелецЭД, НаправлениеЭД, СтатусЭД, НомерЭД, ЭлектронныйДокументВладелец",
		Перечисления.ВидыЭД.ИзвещениеОПолучении, СтруктураВладельцев.Владелец.Контрагент, СтруктураВладельцев.Владелец,
		Перечисления.НаправленияЭД.Исходящий, НовыйСтатусЭД, ДобавленныйФайл.УникальныйИдентификатор(),
		СтруктураВладельцев.ЭлектронныйДокументВладелец);*/
			//ЭлектронныеДокументы.ИзменитьПоСсылкеПрисоединенныйФайл(ДобавленныйФайл, СтруктураИзвещения);
			//ОбновитьВерсиюЭД(СтруктураВладельцев.ЭлектронныйДокументВладелец);
		}
		// Выполняет получение новых электронных документов
		// на основе заведенных соглашений об обмене.
		//

		public object ПолучитьНовыеЭД(/*СоответствиеПаролейДляЭДО = Неопределено*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			/*СтруктураВозврата = Новый Структура("ПараметрыРаспаковки, МассивВозврата, ВызватьОповещение",
		Новый Массив, Неопределено, Ложь);*/
			//МассивВозврата = Новый Массив;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ РАЗРЕШЕННЫЕ РАЗЛИЧНЫЕ
	|	СоглашениеОбИспользованииЭД.АдресРесурсаОрганизации,
	|	СоглашениеОбИспользованииЭД.СпособОбменаЭД
	|ИЗ
	|	Справочник.СоглашенияОбИспользованииЭД КАК СоглашениеОбИспользованииЭД
	|ГДЕ
	|	НЕ СоглашениеОбИспользованииЭД.ПометкаУдаления
	|	И СоглашениеОбИспользованииЭД.СтатусСоглашения = ЗНАЧЕНИЕ(Перечисление.СтатусыСоглашенийЭД.Действует)
	|	И НЕ СоглашениеОбИспользованииЭД.ЭтоТиповое
	|	И НЕ СоглашениеОбИспользованииЭД.ЭтоИнтеркампани";*/
			//РесурсыДляПроверки = Запрос.Выполнить().Выгрузить();
			//ОтборЭП = Новый Структура("СпособОбменаЭД", Перечисления.СпособыОбменаЭД.ЧерезЭлектроннуюПочту);
			//МассивРесурсовЭП = РесурсыДляПроверки.НайтиСтроки(ОтборЭП);
			//ОтборКаталог = Новый Структура("СпособОбменаЭД", Перечисления.СпособыОбменаЭД.ЧерезКаталог);
			//МассивРесурсовКаталоги = РесурсыДляПроверки.НайтиСтроки(ОтборКаталог);
			//СтруктураВозврата.МассивВозврата = МассивВозврата;
			//ОтборСпецОператоров = Новый Структура("СпособОбменаЭД", Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском);
			//МассивРесурсовСпецОператоров = РесурсыДляПроверки.НайтиСтроки(ОтборСпецОператоров);
			if(true/*МассивРесурсовСпецОператоров.Количество() > 0*/)
			{
				//ЭлектронныеДокументыОператорыЭДО.ПолучитьНовыеЭДОператораЭДО(СтруктураВозврата, СоответствиеПаролейДляЭДО);
			}
			return null;
		}

		public object СформироватьХМЛФайлПодтвержденияПолучения(/*ИмяПакетаЭД*/)
		{
			//ИмяФайла = ТекущееИмяВременногоФайла("xml");
			//ЗаписьХМЛ = Новый ЗаписьXML;
			//ЗаписьХМЛ.ОткрытьФайл(ИмяФайла);
			/*// Корневой элемент
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("Подтверждение");
			/*// Имя документа
*/
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ЭлектронныйДокумент");
			//ЗаписьХМЛ.ЗаписатьТекст(ИмяПакетаЭД);
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьНачалоЭлемента("ДатаПолучения");
			//ТекДата = ПреобразоватьДатуВКаноническийВид(ТекущаяДатаСеанса());
			//ЗаписьХМЛ.ЗаписатьТекст(ТекДата);
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.ЗаписатьКонецЭлемента();
			//ЗаписьХМЛ.Закрыть();
			return null;
		}

		public object НеобходимоПолучить(/*Сообщение, СтруктураПараметров*/)
		{
			if(true/*Сообщение.Вложения.Количество() = 0*/)
			{
			}
			if(true/*Сообщение.Вложения.Количество() = 1*/)
			{
				if(true/*Найти(Сообщение.Тема, "Подтверждение")*/)
				{
				}
				if(true/*Найти(Сообщение.Тема, "Обмен эл.документами:")*/)
				{
					//Результат = НеобходимоПолучитьДвоичныеДанные(ДвоичныеДанныеВложения, Вложение.Ключ, СтруктураПараметров);
				}
			}
			return null;
		}

		public object НеобходимоПолучитьДвоичныеДанные(/*ДвоичныеДанные, ИмяФайла, СтруктураПараметров*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			/*// Определим из файла вложений идентификаторы отправителя и получателя
*/
			/*// и сохраним файл на диск
*/
			//ИмяВременногоФайлаЗИП = ТекущееИмяВременногоФайла("zip");
			//ДвоичныеДанные.Записать(ИмяВременногоФайлаЗИП);
			//ЗИПЧтение = Новый ЧтениеZipФайла(ИмяВременногоФайлаЗИП);
			//КлючУникальности = Новый УникальныйИдентификатор();
			//ПапкаДляРаспаковки = РабочийКаталог("ВходящийПакет", КлючУникальности);
			//ЗипЧтение.ИзвлечьВсе(ПапкаДляРаспаковки);
			//РаспакованныеФайлы = НайтиФайлы(ПапкаДляРаспаковки, "*");
			//ФайлИнформации = Неопределено;
			//НастройкиСоглашения = Неопределено;
			if(true/*НЕ ФайлИнформации = Неопределено*/)
			{
				/*// Определим в этом файле строку с отправителем и получателем
*/
				/*// и признак шифрования и попытаемся найти соглашение
*/
				//ЧтениеХМЛ = Новый ЧтениеXML;
				//ЧтениеХМЛ.ОткрытьФайл(ФайлИнформации.ПолноеИмя);
				//Зашифрован = Ложь;
				while(true/*ЧтениеХМЛ.Прочитать()*/)
				{
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Отправитель"*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//ИДОтправителя = ЧтениеХМЛ.Значение;
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Зашифрован"*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//Зашифрован = Зашифрован ИЛИ Булево(ЧтениеХМЛ.Значение);
					}
					if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Получатель"*/)
					{
						//ЧтениеХМЛ.Прочитать();
						//ИДПолучателя = ЧтениеХМЛ.Значение;
					}
				}
				/*;
		
		ЧтениеХМЛ.Закрыть();*/
				//НастройкиСоглашения = ПолучитьНастройкиОбменаЭДПоИД(ИДПолучателя, ИДОтправителя);
			}
			if(true/*ФайлИнформации = Неопределено ИЛИ НастройкиСоглашения = Неопределено*/)
			{
				/*// не нашли файл описанием или нет обмена
*/
				//УдалитьФайлы(ИмяВременногоФайлаЗИП);
				//УдалитьФайлы(ПапкаДляРаспаковки);
			}
			/*// Теперь проверим, что такого транспортного пакета от этого отправителя еще не было
*/
			//ИмяПакета = Лев(ИмяФайла, СтрДлина(ИмяФайла)-4);
			//ЗапросПрисоединенногоФайла = Новый Запрос;
			/*ЗапросПрисоединенногоФайла.Текст =
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	ИСТИНА КАК ЕстьПрисоединенныйФайл
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.ВладелецФайла ССЫЛКА Документ.ПакетЭД
	|	И ВЫРАЗИТЬ(ЭДПрисоединенныеФайлы.ВладелецФайла КАК Документ.ПакетЭД).Направление = &Направление
	|	И ВЫРАЗИТЬ(ЭДПрисоединенныеФайлы.ВладелецФайла КАК Документ.ПакетЭД).Получатель ПОДОБНО &Получатель
	|	И ВЫРАЗИТЬ(ЭДПрисоединенныеФайлы.ВладелецФайла КАК Документ.ПакетЭД).Отправитель ПОДОБНО &Отправитель
	|	И ЭДПрисоединенныеФайлы.Наименование ПОДОБНО &Наименование
	|	И ЭДПрисоединенныеФайлы.ПометкаУдаления = ЛОЖЬ";*/
			//ЗапросПрисоединенногоФайла.УстановитьПараметр("Направление",  Перечисления.НаправленияЭД.Входящий);
			//ЗапросПрисоединенногоФайла.УстановитьПараметр("Получатель",   ИДПолучателя);
			//ЗапросПрисоединенногоФайла.УстановитьПараметр("Отправитель",  ИДОтправителя);
			//ЗапросПрисоединенногоФайла.УстановитьПараметр("Наименование", ИмяПакета);
			//РезультатПустой = ЗапросПрисоединенногоФайла.Выполнить().Пустой();
			//УдалитьФайлы(ИмяВременногоФайлаЗИП);
			//УдалитьФайлы(ПапкаДляРаспаковки);
			if(true/*РезультатПустой*/)
			{
				//СтруктураПараметров = Новый Структура;
				//СтруктураПараметров.Вставить("Получатель",       ИДПолучателя);
				//СтруктураПараметров.Вставить("Отправитель",      ИДОтправителя);
				//СтруктураПараметров.Вставить("Организация",      НастройкиСоглашения.Организация);
				//СтруктураПараметров.Вставить("Контрагент",       НастройкиСоглашения.Контрагент);
				//СтруктураПараметров.Вставить("Соглашение",       НастройкиСоглашения.Основание);
				//СтруктураПараметров.Вставить("АдресОтправителя", НастройкиСоглашения.АдресОтправителя);
				//СтруктураПараметров.Вставить("АдресПолучателя",  НастройкиСоглашения.АдресПолучателя);
				//СтруктураПараметров.Вставить("Зашифрован",       Зашифрован);
			}
			return null;
		}

		public object ОпределитьПодтверждаемыйПакетЭД(/*ПредставлениеПакета*/)
		{
			//СтрокаИдентификатора = СтрЗаменить(ПредставлениеПакета, "EDI_", "");
			//Идентификатор = Новый УникальныйИдентификатор(СтрокаИдентификатора);
			//ДокументПакет = Документы.ПакетЭД.ПолучитьСсылку(Идентификатор);
			if(true/*НЕ ОбщегоНазначения.СсылкаСуществует(ДокументПакет)*/)
			{
				//ДокументПакет = Неопределено;
			}
			return null;
		}

		public object ОбработатьПодтверждениеОператора(/*Сообщение*/)
		{
			return null;
		}

		public object СохранитьДвоичныеДанныеНаЛокальныйДиск(/*ДвоичныеДанные*/)
		{
			/*// Добавить механизм по проверке подписей оператора.
*/
			//ИмяФайла = ТекущееИмяВременногоФайла("xml");
			//ДвоичныеДанные.Записать(ИмяФайла);
			return null;
		}

		public object УжеЕстьДанноеПодтверждение(/*ЭлектронныйДокумент, ИмяФайлаПодтверждения*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ЗапросПодтверждений = Новый Запрос;
			/*ЗапросПодтверждений.Текст =
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	ИСТИНА КАК ЕстьПодтверждение
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	ЭДПрисоединенныеФайлы.ЭлектронныйДокументВладелец = &ЭлектронныйДокументВладелец
	|	И ЭДПрисоединенныеФайлы.Наименование ПОДОБНО &Наименование
	|	И ЭДПрисоединенныеФайлы.ПометкаУдаления = ЛОЖЬ";*/
			//ЗапросПодтверждений.УстановитьПараметр("ЭлектронныйДокументВладелец", ЭлектронныйДокумент);
			//ФайлПодтверждения = Новый Файл(ИмяФайлаПодтверждения);
			//ЗапросПодтверждений.УстановитьПараметр("Наименование", "%" + ФайлПодтверждения.ИмяБезРасширения + "%");
			return null;
		}

		public object ДобавитьПодтверждениеКЭлектроннымДокументамРодителя(/*ИмяФайлаПодтверждения, НомерЭД, НаправлениеДокумента, ЭтоИзвещение = Ложь*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//НомерЭДПоиска = Сред(Лев(НомерЭД, Найти(НомерЭД, "##") - 1), Найти(НомерЭД, "#") + 1);
			//ПараметрыПоиска = Новый Структура("ВидЭД, НаправлениеЭД, НомерЭД", Перечисления.ВидыЭД.ТОРГ12, НаправлениеДокумента, НомерЭД);
			//Владелец = ОпределитьОбъектПривязки(ПараметрыПоиска);
			if(true/*Владелец = Неопределено*/)
			{
			}
			//ВыборкаЭД = ПолучитьВыборкуЭДПоОтбору(Новый Структура("ПометкаУдаления, НомерЭД, ВладелецФайла", Ложь, НомерЭД, Владелец));
			if(true/*НЕ ЗначениеЗаполнено(ВыборкаЭД) ИЛИ НЕ ВыборкаЭД.Следующий()*/)
			{
			}
			//ЭлектронныйДокументВладелец = ВыборкаЭД.Ссылка;
			if(true/*УжеЕстьДанноеПодтверждение(ЭлектронныйДокументВладелец, ?(ЭтоИзвещение, "ИзвещениеОтКонтрагента", "ПодтверждениеОператора"))*/)
			{
			}
			//ЭлектронныйДокументВладелецОбъект = ЭлектронныйДокументВладелец.ПолучитьОбъект();
			//ЭлектронныйДокументВладелецОбъект.ДатаИзмененияСтатусаЭД = ТекущаяДатаСеанса();
			/*ЭлектронныйДокументВладелецОбъект.СтатусЭД = ПолучитьДопустимыйСтатусЭД(?(ЭтоИзвещение, Перечисления.СтатусыЭД.ПолученоИзвещение,
		Перечисления.СтатусыЭД.ПолученоПодтверждение), ЭлектронныйДокументВладелец);*/
			//ЭлектронныйДокументВладелецОбъект.Записать();
			//АдресВоВременномХранилище = ПоместитьВоВременноеХранилище(Новый ДвоичныеДанные(ИмяФайлаПодтверждения));
			/*ДобавленныйФайл = ПрисоединенныеФайлы.ДобавитьФайл(Владелец, ?(ЭтоИзвещение, "ИзвещениеОтКонтрагента", "ПодтверждениеОператора"),
		"xml", ТекущаяДатаСеанса(), ТекущаяДатаСеанса(), АдресВоВременномХранилище, Неопределено, ,"ЭДПрисоединенныеФайлы");*/
			//НовыйСтатусЭД = ПолучитьДопустимыйСтатусЭД(Перечисления.СтатусыЭД.Получен, ДобавленныйФайл);
			/*СтруктураПодтверждения = Новый Структура("ВидЭД, Контрагент, ВладелецЭД, НаправлениеЭД, СтатусЭД, НомерЭД, ЭлектронныйДокументВладелец",
		?(ЭтоИзвещение, Перечисления.ВидыЭД.ИзвещениеОПолучении, Перечисления.ВидыЭД.Подтверждение), Владелец.Контрагент,
		Владелец, Перечисления.НаправленияЭД.Входящий, НовыйСтатусЭД, ДобавленныйФайл.УникальныйИдентификатор(),
		ЭлектронныйДокументВладелец);*/
			//ЭлектронныеДокументы.ИзменитьПоСсылкеПрисоединенныйФайл(ДобавленныйФайл, СтруктураПодтверждения);
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Обмен через каталог
		// Обновляет статусы электронных документов.
		//
		// Параметры:
		//  МассивДокументов - массив ссылок на электронные документы, состояние которых надо обновить,
		//  ПризнакПодписи - булево, признак того, что документы подписаны ЭЦП.
		//

		public void ОбновитьСтатусыЭД(/*МассивДокументов, ПризнакПодписи*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
		}
		// Устанавливает признак шифрования пакету электронных документов.
		//
		// Параметры:
		//  СсылкаНаПакетЭД - Ссылка на пакет электронных документов, которому необходимо установить признак шифрования,
		//  ПараметрыШифрования - Структура, параметры шифрования для данного пакета электронных документов.
		//

		public void ДобавитьПризнакШифрованияПакетуЭД(/*СсылкаНаПакетЭД, ПрисоединенныйФайл, ПараметрыШифрования*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
		}
		// Получает адрес сертификата шифрования во временном хранилище данных.
		//
		// Параметры:
		//  ПрисоединенныйФайл - Ссылка на электронный документ, адрес сертификата шифрования по которому необходимо получить.
		//

		public object ПолучитьМассивАдресовСертификатовШифрования(/*ПрисоединенныйФайл*/)
		{
			//ПараметрыСоглашения = ОпределитьНастройкиОбменаЭДПоИсточнику(ПрисоединенныйФайл.ВладелецФайла, , , ПрисоединенныйФайл);
			if(true/*НЕ ЗначениеЗаполнено(ПараметрыСоглашения)
		ИЛИ ПараметрыСоглашения.СпособОбменаЭД = Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском*/)
			{
			}
			//СертификатКонтрагентаШифрования = ПараметрыСоглашения.СертификатКонтрагентаДляШифрования;
			//СертификатОрганизацииШифрования = ПараметрыСоглашения.СертификатОрганизацииДляРасшифровки;
			//ДвоичныеДанныеСертификата            = СертификатКонтрагентаШифрования.Получить();
			//ДвоичныеДанныеСертификатаОрганизации = СертификатОрганизацииШифрования.ФайлСертификата.Получить();
			if(true/*ДвоичныеДанныеСертификата = Неопределено ИЛИ ДвоичныеДанныеСертификатаОрганизации = Неопределено*/)
			{
			}
			//АдресСертификата = ПоместитьВоВременноеХранилище(ДвоичныеДанныеСертификата);
			//АдресСертификатаОрганизации = ПоместитьВоВременноеХранилище(ДвоичныеДанныеСертификатаОрганизации);
			//МассивВозврата = Новый Массив;
			//МассивВозврата.Добавить(АдресСертификата);
			//МассивВозврата.Добавить(АдресСертификатаОрганизации);
			return null;
		}

		public object НайтиСоздатьПакетЭД(/*ТЗ_ПЭД, ПараметрыСоглашения*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*ПараметрыСоглашения.СпособОбменаЭД = Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском*/)
			{
				/*// Через ОЭДО пакеты формируем с одним вложенным ЭД.
*/
				//НайденнаяСтрока = Неопределено;
			}
			if(true/*НайденнаяСтрока = Неопределено*/)
			{
				//ПЭД                         = Документы.ПакетЭД.СоздатьДокумент();
				//ПЭД.Дата                    = ТекущаяДатаСеанса();
				//ПЭД.Отправитель             = ПараметрыСоглашения.ИдентификаторОрганизации;
				//ПЭД.Получатель              = ПараметрыСоглашения.ИдентификаторКонтрагента;
				//ПЭД.СтатусПакета            = Перечисления.СтатусыПакетовЭД.ПодготовленКОтправке;
				//ПЭД.Направление             = Перечисления.НаправленияЭД.Исходящий;
				//ПЭД.СпособОбменаЭД          = ПараметрыСоглашения.СпособОбменаЭД;
				//ПЭД.АдресРесурсаКонтрагента = ПараметрыСоглашения.АдресРесурсаКонтрагента;
				//ПЭД.АдресРесурсаОрганизации = ПараметрыСоглашения.АдресРесурсаОрганизации;
				//ПЭД.Соглашение              = ПараметрыСоглашения.СоглашениеЭД;
				//ПЭД.Контрагент              = ПараметрыСоглашения.Контрагент;
				//ПЭД.Организация             = ПараметрыСоглашения.Организация;
				//ПЭД.Записать();
				//НовСтрока              = ТЗ_ПЭД.Добавить();
				//НовСтрока.ПЭД          = ПЭД.Ссылка;
				//НовСтрока.Соглашение   = ПараметрыСоглашения.СоглашениеЭД;
				//НовСтрока.АдресРесурса = ПараметрыСоглашения.АдресРесурсаКонтрагента;
			}
			return null;
		}

		public object ПолучитьЭлектронныеДокументыКонвертов(/*Конверт*/)
		{
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Распаковка пакетов электронных документов

		public void ДобавитьМассив(/*МассивПриемник, МассивИсточник*/)
		{
			if(true/*ТипЗнч(МассивИсточник) <> Тип("Массив")*/)
			{
			}
		}

		public object ОпределитьНаправление(/*СтруктураФайлаЭД*/)
		{
			if(true/*СтруктураФайлаЭД.ВидЭД = Перечисления.ВидыЭД.ЗаказТовара И СтруктураФайлаЭД.ПризнакПродавца*/)
			{
			}
			return null;
		}

		public object НайтиСтруктуруВПараметрах(/*ИмяПоиска, ПараметрыШифрования*/)
		{
			if(true/*ТипЗнч(ПараметрыШифрования) = Тип("Массив")*/)
			{
			}
			return null;
		}

		public object ОпределитьОбъектПривязки(/*СтруктураПараметровДокумента*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*СтруктураПараметровДокумента.ВидЭД = Перечисления.ВидыЭД.КаталогТоваров*/)
			{
			}
			//ПозПодстроки = Найти(СтруктураПараметровДокумента.НомерЭД, "##") - 1;
			if(true/*ПозПодстроки > 0*/)
			{
				//ЭлектронныйНомерДокумента = Лев(СтруктураПараметровДокумента.НомерЭД, ПозПодстроки);
			}
			//ЗапросДокументовОснований = Новый Запрос;
			/*ЗапросДокументовОснований.Текст =
	"ВЫБРАТЬ ПЕРВЫЕ 1
	|	ЭДПрисоединенныеФайлы.ВладелецФайла.Ссылка КАК Ссылка
	|ИЗ
	|	Справочник.ЭДПрисоединенныеФайлы КАК ЭДПрисоединенныеФайлы
	|ГДЕ
	|	(НЕ ЭДПрисоединенныеФайлы.ВладелецФайла ССЫЛКА Документ.ПакетЭД)
	|	И ЭДПрисоединенныеФайлы.ПометкаУдаления = ЛОЖЬ
	|	И ЭДПрисоединенныеФайлы.НомерЭД ПОДОБНО &Параметр
	|	И ЭДПрисоединенныеФайлы.ВидЭД = &ВидЭД
	|	И ЭДПрисоединенныеФайлы.НаправлениеЭД = &НаправлениеЭД";*/
			//ЗапросДокументовОснований.УстановитьПараметр("НаправлениеЭД", СтруктураПараметровДокумента.НаправлениеЭД);
			//ЗапросДокументовОснований.УстановитьПараметр("Параметр",      ЭлектронныйНомерДокумента + "%");
			//ЗапросДокументовОснований.УстановитьПараметр("ВидЭД",         СтруктураПараметровДокумента.ВидЭд);
			//НайденныеДокументы = ЗапросДокументовОснований.Выполнить().Выбрать();
			if(true/*НайденныеДокументы.Следующий()*/)
			{
			}
			return null;
		}

		public object ЕстьТакаяПодпись(/*ДвоичныеДанныеПроверки, ЭлектронныйДокумент*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			if(true/*НЕ ЗначениеЗаполнено(ЭлектронныйДокумент)*/)
			{
			}
			return null;
		}

		public object ПолучитьСоответствиеФайлПараметры(/*ФайлИнформации*/)
		{
			//ЧтениеХМЛ = Новый ЧтениеXML;
			//ЧтениеХМЛ.ОткрытьФайл(ФайлИнформации.ПолноеИмя);
			//ПредставлениеДокумента = "";
			//ПредставленияПодписей = Новый Массив;
			//НашлиДокумент = Ложь;
			//СоответствиеВозврата = Новый Соответствие;
			while(true/*ЧтениеХМЛ.Прочитать()*/)
			{
				//Параметры = Новый Структура;
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Текст"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//СоответствиеВозврата.Вставить("Текст", ЧтениеХМЛ.Значение);
				}
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Документ"*/)
				{
					//ПредставлениеДокумента = "";
					//ПредставленияПодписей.Очистить();
					//ЧтениеХМЛ.Прочитать();
					//ПредставлениеДокумента = СокрЛП(ЧтениеХМЛ.Значение);
					//НашлиДокумент = Истина;
					//НомерЭД = "";
				}
				if(true/*НЕ НашлиДокумент*/)
				{
				}
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Подпись"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//ПредставленияПодписей.Добавить(СокрЛП(ЧтениеХМЛ.Значение));
				}
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "НомерЭД"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//НомерЭД = ЧтениеХМЛ.Значение;
				}
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.КонецЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "Документ"*/)
				{
					//НашлиДокумент = Ложь;
					//НовыйМассив = ПредставленияПодписей;
					/*СоответствиеВозврата.Вставить(ПредставлениеДокумента, Новый Структура("Подписи, НомерЭД",
				ВернутьМассивПредставленийПодписей(ПредставленияПодписей),НомерЭД));*/
				}
			}
			return null;
		}

		public object ВернутьМассивПредставленийПодписей(/*МассивПредставления*/)
		{
			//МассивВозврата = Новый Массив;
			return null;
		}

		public object ВернутьМассивОтпечатковСтруктуры(/*СтруктураСертификатов*/)
		{
			//МассивВозврата = Новый Массив;
			return null;
		}

		public object ПреобразоватьМассивФайловВДвоичныеДанные(/*МассивФайлов*/)
		{
			//МассивВозврата = Новый Массив;
			return null;
		}

		public object ПолучитьФайлДанныхДляОбработки(/*СтруктураДанных, ПапкаДляРасшифровки*/)
		{
			//ФайлДанныхОбработан = Ложь;
			if(true/*ЗначениеЗаполнено(ПапкаДляРасшифровки)*/)
			{
				if(true/*НайтиФайлы(ПапкаДляРасшифровки).Количество() = 0*/)
				{
					//СоздатьКаталог(ПапкаДляРасшифровки);
				}
				if(true/*НайтиФайлы(ПапкаДляРасшифровки).Количество() > 0*/)
				{
					//УдалитьФайлы(ПапкаДляРасшифровки, "*");
					//ФайлДанных = СтруктураДанных.ДвоичныеДанные;
					//Расширение = СтрЗаменить(СтруктураДанных.ИмяФайла, СтруктураДанных.ИмяФайлаБезРасширения, "");
					//ФайлРасшифрованногоАрхива = ТекущееИмяВременногоФайла(Расширение);
					//ФайлДанных.Записать(ФайлРасшифрованногоАрхива);
					if(true/*Найти(Расширение, "zip") > 0*/)
					{
						//ЧтениеЗИП = Новый ЧтениеZIPФайла(ФайлРасшифрованногоАрхива);
						//ЧтениеЗИП.ИзвлечьВсе(ПапкаДляРасшифровки);
						//ФайлДанныхОбработан = Истина;
					}
					//УдалитьФайлы(ФайлРасшифрованногоАрхива);
				}
			}
			return null;
		}

		public object ОбработатьИзвещениеОператора(/*ПакетЭД, СтруктураДанныхПодписей, СтруктураДанных, СоответствиеФайлПараметры*/)
		{
			//ДвоичныеДанныеИзвещения = СтруктураДанных.ДвоичныеДанные;
			//ИмяФайлаЧтенияХМЛ = ТекущееИмяВременногоФайла("xml");
			//ДвоичныеДанныеИзвещения.Записать(ИмяФайлаЧтенияХМЛ);
			//ФайлЧтенияХМЛ = Новый Файл(ИмяФайлаЧтенияХМЛ);
			//ЧтениеХМЛ = Новый ЧтениеXML;
			//ЧтениеХМЛ.ОткрытьФайл(ИмяФайлаЧтенияХМЛ);
			//ИдентификаторЭлектронногоДокумента = "";
			while(true/*ЧтениеХМЛ.Прочитать()*/)
			{
				if(true/*ЧтениеХМЛ.ТипУзла = ТипУзлаXML.НачалоЭлемента И ЧтениеХМЛ.ЛокальноеИмя = "ИДПодтверждения"*/)
				{
					//ЧтениеХМЛ.Прочитать();
					//ИдентификаторЭлектронногоДокумента = ЧтениеХМЛ.Значение;
				}
			}
			/*;
	
	ЧтениеХМЛ.Закрыть();*/
			if(true/*Не ПустаяСтрока(ИдентификаторЭлектронногоДокумента)*/)
			{
				/*СтруктураВладельцев = ДобавитьПодтверждениеКЭлектроннымДокументамРодителя(ИмяФайлаЧтенияХМЛ,
			ИдентификаторЭлектронногоДокумента, Перечисления.НаправленияЭД.Исходящий, Истина);*/
			}
			//УдалитьФайлы(ИмяФайлаЧтенияХМЛ);
			return null;
		}

		public object ПолучитьИмяФайлаДанныхЭД(/*СсылкаНаЭД*/)
		{
			//ИмяФайлаДанных = "";
			//ДопИнформацияПоЭД = ПрисоединенныеФайлы.ПолучитьДанныеФайла(СсылкаНаЭД);
			if(true/*ДопИнформацияПоЭД.Свойство("СсылкаНаДвоичныеДанныеФайла")
		И ЗначениеЗаполнено(ДопИнформацияПоЭД.СсылкаНаДвоичныеДанныеФайла)*/)
			{
				//ДанныеЭД = ПолучитьИзВременногоХранилища(ДопИнформацияПоЭД.СсылкаНаДвоичныеДанныеФайла);
				if(true/*ЗначениеЗаполнено(ДопИнформацияПоЭД.Расширение)*/)
				{
					//ИмяФайла = ТекущееИмяВременногоФайла(ДопИнформацияПоЭД.Расширение);
				}
				//ДанныеЭД.Записать(ИмяФайла);
				if(true/*Найти(ДопИнформацияПоЭД.Расширение, "zip") > 0*/)
				{
					//ЗИПЧтение = Новый ЧтениеZipФайла(ИмяФайла);
					//ПапкаДляРаспаковки = РабочийКаталог(, СсылкаНаЭД.УникальныйИдентификатор());
					//УдалитьФайлы(ПапкаДляРаспаковки, "*.*");
					//ЗипЧтение.ИзвлечьВсе(ПапкаДляРаспаковки);
					//ФайлыАрхиваXML = НайтиФайлы(ПапкаДляРаспаковки, "*.xml");
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Обработка электронных документов
		// Устанавливает признак того, что электронный документ был утвержден.
		//
		// Параметры:
		//  ПрисоединенныйФайл - ссылка на электронный документ, который необходимо обработать.
		//

		public void УстановитьПризнакУтвержден(/*ПрисоединенныйФайл*/)
		{
			/*// Проверим, все ли необходимые условия выполнены
*/
			if(true/*ЭлектронныеДокументыПереопределяемый.ЭлектронныйДокументГотовКУтверждению(ПрисоединенныйФайл)*/)
			{
			}
			if(true/*ТранзакцияАктивна() И ПрисоединенныйФайл.НаправлениеЭД = Перечисления.НаправленияЭД.Входящий
		И (ПрисоединенныйФайл.ВидЭД = Перечисления.ВидыЭД.ТОРГ12Продавец
		ИЛИ ПрисоединенныйФайл.ВидЭД = Перечисления.ВидыЭД.АктИсполнитель)*/)
			{
				if(true/*ПрисоединенныйФайл.ВидЭД = Перечисления.ВидыЭД.ТОРГ12Продавец*/)
				{
					//НовыйЭД = ЭлектронныеДокументыФорматОбмена.СформироватьЭДТорг12Покупатель(ПрисоединенныйФайл);
				}
				if(true/*НовыйЭД = Неопределено*/)
				{
					//ОтменитьТранзакцию();
				}
			}
		}
		// Процедура определяет, по каким объектам ИБ не надо выполнять действия (утверждение,
		// подписание, подготовка к отправке).
		//
		// Параметры:
		//  НастройкиОбъектов - соответствие, содержит ссылки на документы ИБ,
		//                     по которым предполагается выполнение каких-либо действий с ЭД.
		//  МассивНеобрабатываемыхОбъектов - массив, возвращает в вызывающую процедуру ссылки на объекты ИБ,
		//                                  по которым не надо выполнять никаких действий.
		//

		public void ОпределитьНеобрабатываемыеОбъекты(/*НастройкиОбъектов, МассивНеобрабатываемыхОбъектов*/)
		{
			//МассивОтбора = Новый Массив;
			//Запрос = Новый Запрос;
			/*Запрос.Текст =
	"ВЫБРАТЬ
	|	СостоянияЭД.СсылкаНаОбъект,
	|	СостоянияЭД.ЭлектронныйДокумент
	|ИЗ
	|	РегистрСведений.СостоянияЭД КАК СостоянияЭД
	|ГДЕ
	|	СостоянияЭД.СсылкаНаОбъект В(&МассивСсылок)
	|	И (СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.ОжидаетсяОтправка)
	|			ИЛИ СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.ОжидаетсяПодтверждение)
	|			ИЛИ СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.ОбменЗавершен)
	|			ИЛИ СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.ОжидаетсяИзвещениеОПолучении)
	|				И ИСТИНА)";*/
			//ИмяСчетаФактурыВыданного = ЭлектронныеДокументыПовтИсп.ИмяНаличиеОбъектаРеквизитаВПрикладномРешении("СчетФактураВыданныйВМетаданных");
			if(true/*ИмяСчетаФактурыВыданного <> Неопределено*/)
			{
				/*Запрос.Текст = СтрЗаменить(Запрос.Текст, "И ИСТИНА", "ИЛИ СостоянияЭД.СсылкаНаОбъект ССЫЛКА Документ." + ИмяСчетаФактурыВыданного + "
		|				И (СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.ОжидаетсяИзвещениеОПолучении)
		|					ИЛИ СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.ОбменЗавершен)
		|					ИЛИ СостоянияЭД.СостояниеВерсииЭД = ЗНАЧЕНИЕ(Перечисление.СостоянияВерсийЭД.Отклонен))");*/
			}
			//Запрос.УстановитьПараметр("МассивСсылок", МассивОтбора);
			//Результат = Запрос.Выполнить().Выбрать();
			while(true/*Результат.Следующий()*/)
			{
				//МассивНеобрабатываемыхОбъектов.Добавить(Результат.ЭлектронныйДокумент);
				/*ТекстСообщения = НСтр("ru = 'Обработка %1.
		|Не требуется выполнения действий с электронным документом.'");*/
				//ТекстСообщения = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ТекстСообщения, Результат.СсылкаНаОбъект);
				//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(ТекстСообщения);
			}
			//;;
		}
		// Определяет необходимость выполнения какого-либо действия
		// с электронным документом с нашей стороны, либо ожидание действия получателя,
		// на основании статуса текущего электронного документа.
		//
		// Параметры:
		//  СсылкаНаЭД - СправочникСсылка.ЭДПрисоединенныеФайлы, ссылка на электронный документ.
		//

		public object ОпределитьСводнуюИнформациюПоСтатусуЭД(/*СсылкаНаЭД*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			/*СтруктураДействий = Новый Структура("СНашейСтороны, СоСтороныДругогоУчастника",
		Перечисления.СводныеСостоянияЭД.ДействийНеТребуется, Перечисления.СводныеСостоянияЭД.ДействийНеТребуется);*/
			if(true/*СсылкаНаЭД <> Неопределено*/)
			{
				if(true/*СсылкаНаЭД.ВидЭД <> Перечисления.ВидыЭД.СчетФактура*/)
				{
					if(true/*СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.Сформирован
				ИЛИ СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.Утвержден
				ИЛИ СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.Подписан
				ИЛИ СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.Получен
				ИЛИ СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.ПодготовленКОтправке
				ИЛИ СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.ПодготовленоПодтверждение*/)
					{
						//СтруктураДействий.СНашейСтороны = Перечисления.СводныеСостоянияЭД.ТребуютсяДействия;
					}
					if(true/*СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.ПереданОператору
				ИЛИ СсылкаНаЭД.СтатусЭД = Перечисления.СтатусыЭД.Отправлен*/)
					{
						//СтруктураДействий.СоСтороныДругогоУчастника = Перечисления.СводныеСостоянияЭД.ТребуютсяДействия;
					}
				}
			}
			if(true/*СтруктураДействий.СоСтороныДругогоУчастника = Перечисления.СводныеСостоянияЭД.ДействийНеТребуется
		И СтруктураДействий.СНашейСтороны = Перечисления.СводныеСостоянияЭД.ДействийНеТребуется*/)
			{
				//СтруктураДействий.СНашейСтороны = Перечисления.СводныеСостоянияЭД.ВсеВыполнено;
				//СтруктураДействий.СоСтороныДругогоУчастника = Перечисления.СводныеСостоянияЭД.ВсеВыполнено;
			}
			return null;
		}
		// Определяет необходимость конкретного действия из перечня действий.
		//
		// Параметры:
		//  ПереченьДействий - Строка, перечень действий, которые должны быть совершены с объектом
		//  Действие - Строка, конкретное действие, которое нужно найти в перечне действий
		//
		// Возвращаемое значение:
		//  Булево - Если действие найдено - возвращается Истина, иначе Ложь
		//

		public object ЕстьДействие(/*ПереченьДействий, Действие*/)
		{
			if(true/*Найти(ПереченьДействий, Действие) > 0*/)
			{
			}
			return null;
		}

		public object ТаблицаПоЭД(/*СсылкаНаЭД*/)
		{
			//РеквизитыЭД = ОбщегоНазначения.ПолучитьЗначенияРеквизитов(СсылкаНаЭД, "Ссылка, СтатусЭД, ВидЭД, СоглашениеЭД, ВладелецФайла");
			//ТЗВозврата = Новый ТаблицаЗначений;
			//ТЗВозврата.Колонки.Добавить("СсылкаНаЭД");
			//ТЗВозврата.Колонки.Добавить("СтатусЭД");
			//ТЗВозврата.Колонки.Добавить("ВидЭД");
			//ТЗВозврата.Колонки.Добавить("Соглашение");
			//ТЗВозврата.Колонки.Добавить("ВладелецЭД");
			//НовСтрока = ТЗВозврата.Добавить();
			//НовСтрока.СсылкаНаЭД = РеквизитыЭД.Ссылка;
			//НовСтрока.СтатусЭД   = РеквизитыЭД.СтатусЭД;
			//НовСтрока.ВидЭД      = РеквизитыЭД.ВидЭД;
			//НовСтрока.Соглашение = РеквизитыЭД.СоглашениеЭД;
			//НовСтрока.ВладелецЭД = РеквизитыЭД.ВладелецФайла;
			return null;
		}

		public object ЭтоОтправкаПодтверждения(/*ПрисоединенныйФайл*/)
		{
			//Возврат ПрисоединенныйФайл.НаправлениеЭД = Перечисления.НаправленияЭД.Входящий;
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Работа с версиями электронных документов

		public object ПолучитьТекстСводногоСостоянияЭД(/*СсылкаНаВладельца*/)
		{
			//УстановитьПривилегированныйРежим(Истина);
			//ТекстСводногоСостояния = "";
			//МассивСсылок = Новый Массив;
			//МассивСсылок.Добавить(СсылкаНаВладельца);
			//ТаблицаДанных = ПолучитьДанныеЭДПоВладельцам(МассивСсылок);
			if(true/*ТаблицаДанных.Количество() > 0*/)
			{
				//Строка = ТаблицаДанных[0];
				//ТекстСНашейСтороны = "";
				//ТекстСоСтороныДругогоУчастника = "";
				if(true/*ЗначениеЗаполнено(Строка.ДействияСНашейСтороны)
			И Строка.ДействияСНашейСтороны = Перечисления.СводныеСостоянияЭД.ТребуютсяДействия*/)
				{
					//ТекстСНашейСтороны = НСтр("ru = 'с нашей стороны'");
				}
				if(true/*ЗначениеЗаполнено(Строка.ДействияСоСтороныДругогоУчастника)
			И Строка.ДействияСоСтороныДругогоУчастника = Перечисления.СводныеСостоянияЭД.ТребуютсяДействия*/)
				{
					//ТекстСоСтороныДругогоУчастника = НСтр("ru = 'со стороны других участников'");
				}
				if(true/*ЗначениеЗаполнено(ТекстСНашейСтороны) ИЛИ ЗначениеЗаполнено(ТекстСоСтороныДругогоУчастника)*/)
				{
					/*ТекстСводногоСостояния = НСтр("ru = 'Требуются действия '") + ТекстСНашейСтороны
				+ ?(ЗначениеЗаполнено(ТекстСНашейСтороны) И ЗначениеЗаполнено(ТекстСоСтороныДругогоУчастника), " и ", "")
				+ ТекстСоСтороныДругогоУчастника;*/
				}
			}
			return null;
		}
		////////////////////////////////////////////////////////////////////////////////
		// Оповещение пользователя об обработке ЭД
		// Выводит сообщение пользователю о нехватки прав доступа.

		public void СообщитьПользователюОНарушенииПравДоступа(/**/)
		{
			//ТекстСообщения = НСтр("ru = 'Нарушение прав доступа'");
			//ЭлектронныеДокументыПереопределяемый.ПодготовитьТекстСообщенияОНарушенииПравДоступа(ТекстСообщения);
			//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(ТекстСообщения);
		}
		////////////////////////////////////////////////////////////////////////////////
		// Прочие

		public void СообщитьОбОтсутствииСоглашенияЭД(/*ПараметрыЭД, Источник*/)
		{
			if(true/*НЕ ЭлектронныеДокументыПереопределяемый.ПроверитьПравильностьЗаполненияОбъекта(ПараметрыЭД)*/)
			{
			}
			/*ШаблонСообщения = Нстр("ru = 'Обработка %1.
	|Операция не выполнена!
	|Введите действующее ""Соглашение об использовании электронных документов"" с реквизитами:'");*/
			//Текст = СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку(ШаблонСообщения, Источник);
			//ТаблицаПараметров = Новый ТаблицаЗначений();
			//ТаблицаПараметров.Колонки.Добавить("Ключ");
			//ТаблицаПараметров.Колонки.Добавить("Значение");
			//ТаблицаПараметров.Колонки.Добавить("Порядок");
			//ЭтоСчетФактураВыданный = Ложь;
			if(true/*ПараметрыЭД.Свойство("ЭтоСчетФактураВыданный") И ЗначениеЗаполнено(ПараметрыЭД.ЭтоСчетФактураВыданный)*/)
			{
				//ЭтоСчетФактураВыданный = ПараметрыЭД.ЭтоСчетФактураВыданный;
			}
			//ТаблицаПараметров.Сортировать("Порядок");
			//ОбщегоНазначенияКлиентСервер.СообщитьПользователю(Текст);
		}

		public object НастройкиОбменаЭД(/*СсылкаНаЭД*/)
		{
			//НастройкиОбмена = Неопределено;
			if(true/*ЗначениеЗаполнено(СсылкаНаЭД)*/)
			{
				if(true/*ТипЗнч(СсылкаНаЭД) = Тип("ДокументСсылка.ПроизвольныйЭД")*/)
				{
					//РеквизитыЭД = ОпределитьНастройкиОбменаЭДПоИсточнику(СсылкаНаЭД);
				}
				if(true/*ЗначениеЗаполнено(РеквизитыЭД)*/)
				{
					//НастройкиОбмена = Новый Структура;
					/*НастройкиОбмена.Вставить("СпособОбмена",
				ОбщегоНазначения.ПолучитьЗначениеРеквизита(РеквизитыЭД.СоглашениеЭД, "СпособОбменаЭД"));*/
					//НастройкиОбмена.Вставить("Направление", РеквизитыЭД.НаправлениеЭД);
					//НастройкиОбмена.Вставить("ВидЭД", РеквизитыЭД.ВидЭД);
					//НастройкиОбмена.Вставить("ИспользоватьПодпись", Истина);
					//НастройкиОбмена.Вставить("ИспользоватьКвитанции", Ложь);
					if(true/*НастройкиОбмена.СпособОбмена <> Перечисления.СпособыОбменаЭД.ЧерезОператораЭДОТакском*/)
					{
						//ЗапросПоНастройкам = Новый Запрос;
						//ЗапросПоНастройкам.УстановитьПараметр("СоглашениеЭД",  РеквизитыЭД.СоглашениеЭД);
						//ЗапросПоНастройкам.УстановитьПараметр("НаправлениеЭД", РеквизитыЭД.НаправлениеЭД);
						//ЗапросПоНастройкам.УстановитьПараметр("ВидЭД",         РеквизитыЭД.ВидЭД);
						/*ЗапросПоНастройкам.Текст =
				"ВЫБРАТЬ
				|	Соглашение.ИспользоватьПодпись,
				|	Соглашение.ИспользоватьКвитанции
				|ИЗ
				|	(ВЫБРАТЬ
				|		СоглашенияОбИспользованииЭДВходящиеДокументы.ИспользоватьЭЦП КАК ИспользоватьПодпись,
				|		СоглашенияОбИспользованииЭДВходящиеДокументы.ОжидатьКвитанциюОДоставке КАК ИспользоватьКвитанции,
				|		ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Входящий) КАК НаправлениеЭД
				|	ИЗ
				|		Справочник.СоглашенияОбИспользованииЭД.ВходящиеДокументы КАК СоглашенияОбИспользованииЭДВходящиеДокументы
				|	ГДЕ
				|		СоглашенияОбИспользованииЭДВходящиеДокументы.ВходящийДокумент = &ВидЭД
				|		И СоглашенияОбИспользованииЭДВходящиеДокументы.Ссылка = &СоглашениеЭД
				|		И СоглашенияОбИспользованииЭДВходящиеДокументы.Формировать
				|	
				|	ОБЪЕДИНИТЬ ВСЕ
				|	
				|	ВЫБРАТЬ
				|		СоглашенияОбИспользованииЭДИсходящиеДокументы.ИспользоватьЭЦП,
				|		СоглашенияОбИспользованииЭДИсходящиеДокументы.ОжидатьКвитанциюОДоставке,
				|		ВЫБОР
				|			КОГДА &НаправлениеЭД = ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Интеркампани)
				|				ТОГДА ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Интеркампани)
				|			ИНАЧЕ ЗНАЧЕНИЕ(Перечисление.НаправленияЭД.Исходящий)
				|		КОНЕЦ
				|	ИЗ
				|		Справочник.СоглашенияОбИспользованииЭД.ИсходящиеДокументы КАК СоглашенияОбИспользованииЭДИсходящиеДокументы
				|	ГДЕ
				|		СоглашенияОбИспользованииЭДИсходящиеДокументы.ИсходящийДокумент = &ВидЭД
				|		И СоглашенияОбИспользованииЭДИсходящиеДокументы.Ссылка = &СоглашениеЭД
				|		И СоглашенияОбИспользованииЭДИсходящиеДокументы.Формировать) КАК Соглашение
				|ГДЕ
				|	Соглашение.НаправлениеЭД = &НаправлениеЭД";*/
						//Результат = ЗапросПоНастройкам.Выполнить();
						if(true/*НЕ Результат.Пустой()*/)
						{
							//ТЗ = Результат.Выгрузить();
							//ЗаполнитьЗначенияСвойств(НастройкиОбмена, ТЗ[0]);
						}
					}
				}
			}
			return null;
		}
	}
}
